sql_parse.cc 156 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 18
   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"
#include "sql_acl.h"
19
#include "sql_repl.h"
20
#include "repl_failsafe.h"
unknown's avatar
unknown committed
21 22 23 24
#include <m_ctype.h>
#include <myisam.h>
#include <my_dir.h>

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

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

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

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 57
static void remove_escape(char *name);
static void refresh_status(void);
unknown's avatar
unknown committed
58 59
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name);
unknown's avatar
unknown committed
60

61
const char *any_db="*any*";	// Special symbol for check_access
unknown's avatar
unknown committed
62 63 64 65 66

const char *command_name[]={
  "Sleep", "Quit", "Init DB", "Query", "Field List", "Create DB",
  "Drop DB", "Refresh", "Shutdown", "Statistics", "Processlist",
  "Connect","Kill","Debug","Ping","Time","Delayed_insert","Change user",
unknown's avatar
unknown committed
67
  "Binlog Dump","Table Dump",  "Connect Out", "Register Slave",
unknown's avatar
unknown committed
68
  "Prepare", "Prepare Execute", "Long Data", "Close stmt",
69
  "Error"					// Last command number
unknown's avatar
unknown committed
70 71
};

72
static char empty_c_string[1]= {0};		// Used for not defined 'db'
unknown's avatar
unknown committed
73 74 75 76

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

unknown's avatar
unknown committed
93 94 95 96 97 98 99 100 101 102
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
  }
}

103

unknown's avatar
unknown committed
104
static bool end_active_trans(THD *thd)
105
{
unknown's avatar
unknown committed
106
  int error=0;
unknown's avatar
unknown committed
107
  if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
unknown's avatar
unknown committed
108
		      OPTION_TABLE_LOCK))
109
  {
110 111
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
112
    if (ha_commit(thd))
unknown's avatar
unknown committed
113
      error=1;
114
  }
unknown's avatar
unknown committed
115
  return error;
116 117 118
}


unknown's avatar
unknown committed
119
#ifdef HAVE_REPLICATION
120 121 122
inline bool all_tables_not_ok(THD *thd, TABLE_LIST *tables)
{
  return (table_rules_on && tables && !tables_ok(thd,tables) &&
unknown's avatar
unknown committed
123
          ((thd->lex->sql_command != SQLCOM_DELETE_MULTI) ||
unknown's avatar
unknown committed
124 125
           !tables_ok(thd,
		      (TABLE_LIST *)thd->lex->auxilliary_table_list.first)));
126
}
unknown's avatar
unknown committed
127
#endif
128 129


130 131
static HASH hash_user_connections;

unknown's avatar
unknown committed
132 133
static int get_or_create_user_conn(THD *thd, const char *user,
				   const char *host,
unknown's avatar
unknown committed
134
				   USER_RESOURCES *mqh)
135 136
{
  int return_val=0;
unknown's avatar
unknown committed
137
  uint temp_len, user_len;
138 139 140 141 142 143
  char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];
  struct  user_conn *uc;

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

144 145
  user_len=strlen(user);
  temp_len= (strmov(strmov(temp_user, user)+1, host) - temp_user)+1;
146
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
147 148
  if (!(uc = (struct  user_conn *) hash_search(&hash_user_connections,
					       (byte*) temp_user, temp_len)))
149
  {
unknown's avatar
unknown committed
150 151 152
    /* 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
153 154
			 MYF(MY_WME)))))
    {
155
      send_error(thd, 0, NullS);		// Out of memory
156 157
      return_val=1;
      goto end;
unknown's avatar
unknown committed
158
    }
159 160
    uc->user=(char*) (uc+1);
    memcpy(uc->user,temp_user,temp_len+1);
161 162
    uc->user_len= user_len;
    uc->host=uc->user + uc->user_len +  1;
163
    uc->len = temp_len;
164 165 166
    uc->connections = 1;
    uc->questions=uc->updates=uc->conn_per_hour=0;
    uc->user_resources=*mqh;
unknown's avatar
unknown committed
167
    if (max_user_connections && mqh->connections > max_user_connections)
168
      uc->user_resources.connections = max_user_connections;
169
    uc->intime=thd->thr_create_time;
unknown's avatar
SCRUM  
unknown committed
170
    if (my_hash_insert(&hash_user_connections, (byte*) uc))
171 172
    {
      my_free((char*) uc,0);
173
      send_error(thd, 0, NullS);		// Out of memory
174 175 176 177 178
      return_val=1;
      goto end;
    }
  }
  thd->user_connect=uc;
179
  uc->connections++;
180 181 182
end:
  (void) pthread_mutex_unlock(&LOCK_user_conn);
  return return_val;
unknown's avatar
unknown committed
183

184
}
185 186 187


/*
188
    Check if user exist and password supplied is correct. 
189 190
  SYNOPSIS
    check_user()
191 192 193 194 195 196 197 198 199
    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

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

205 206 207
  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
208 209
   -1  access denied or handshake error; error is sent to client;
   >0  error, not sent to client
unknown's avatar
unknown committed
210 211
*/

unknown's avatar
unknown committed
212 213 214
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
215
{
216
  DBUG_ENTER("check_user");
unknown's avatar
unknown committed
217
  
unknown's avatar
unknown committed
218 219
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  thd->master_access= GLOBAL_ACLS;			// Full rights
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
  /* 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
235 236
#else

237 238 239 240 241
  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);
  
242
  /*
243 244
    If the server is running in secure auth mode, short scrambles are 
    forbidden.
245
  */
246
  if (opt_secure_auth_local && passwd_len == SCRAMBLE_LENGTH_323)
unknown's avatar
unknown committed
247
  {
248 249 250
    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
251
  }
unknown's avatar
unknown committed
252 253 254 255
  if (passwd_len != 0 &&
      passwd_len != SCRAMBLE_LENGTH &&
      passwd_len != SCRAMBLE_LENGTH_323)
    DBUG_RETURN(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
256

257
  /*
258 259 260 261
    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'.
262
  */
263 264
  thd->db= 0;
  thd->db_length= 0;
unknown's avatar
unknown committed
265
  
266
  USER_RESOURCES ur;
267
  int res= acl_getroot(thd, &ur, passwd, passwd_len);
unknown's avatar
unknown committed
268
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
269
  if (res == -1)
unknown's avatar
unknown committed
270
  {
unknown's avatar
unknown committed
271 272 273 274 275 276
    /*
      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.
    */
277
    NET *net= &thd->net;
278
    if (opt_secure_auth_local)
279
    {
280 281 282 283 284 285
      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);
    }
286
    if (send_old_password_request(thd) ||
unknown's avatar
unknown committed
287 288 289 290 291 292 293
        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 */
294
    res= acl_getroot(thd, &ur, (char *) net->read_pos, SCRAMBLE_LENGTH_323);
unknown's avatar
unknown committed
295
  }
unknown's avatar
unknown committed
296
#endif /*EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
297 298
  /* here res is always >= 0 */
  if (res == 0)
unknown's avatar
unknown committed
299
  {
unknown's avatar
unknown committed
300
    if (!(thd->master_access & NO_ACCESS)) // authentification is OK 
301
    {
unknown's avatar
unknown committed
302 303 304 305 306 307 308 309 310 311
      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)
312
      {
unknown's avatar
unknown committed
313 314
        VOID(pthread_mutex_lock(&LOCK_thread_count));
        bool count_ok= thread_count < max_connections + delayed_insert_threads
315
                       || (thd->master_access & SUPER_ACL);
unknown's avatar
unknown committed
316 317 318 319 320 321
        VOID(pthread_mutex_unlock(&LOCK_thread_count));
        if (!count_ok)
        {                                         // too many connections 
          send_error(thd, ER_CON_COUNT_ERROR);
          DBUG_RETURN(-1);
        }
322
      }
unknown's avatar
unknown committed
323

unknown's avatar
unknown committed
324 325 326 327 328 329 330 331
      /* 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*) "");

332
      /*
333 334 335
        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.
336
      */
unknown's avatar
unknown committed
337 338 339
      thd->db_access=0;

      /* Don't allow user to connect if he has done too many queries */
unknown's avatar
unknown committed
340 341 342 343 344 345 346 347 348
      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
349 350 351

      /* Change database if necessary: OK or FAIL is sent in mysql_change_db */
      if (db && db[0])
352
      {
unknown's avatar
unknown committed
353 354 355 356 357 358
        if (mysql_change_db(thd, db))
        {
          if (thd->user_connect)
            decrease_user_connections(thd->user_connect);
          DBUG_RETURN(-1);
        }
359 360
      }
      else
unknown's avatar
unknown committed
361
	send_ok(thd);
unknown's avatar
unknown committed
362 363 364
      thd->password= test(passwd_len);          // remember for error messages 
      /* Ready to handle queries */
      DBUG_RETURN(0);
unknown's avatar
unknown committed
365 366
    }
  }
unknown's avatar
unknown committed
367
  else if (res == 2) // client gave short hash, server has long hash
unknown's avatar
unknown committed
368
  {
unknown's avatar
unknown committed
369 370 371
    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
372
  }
unknown's avatar
unknown committed
373 374 375 376 377 378 379 380 381
  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
382
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
383 384
}

unknown's avatar
unknown committed
385
/*
unknown's avatar
unknown committed
386 387
  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
388 389
*/

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

397
extern "C" void free_user(struct user_conn *uc)
unknown's avatar
unknown committed
398 399 400 401
{
  my_free((char*) uc,MYF(0));
}

unknown's avatar
unknown committed
402
void init_max_user_conn(void)
unknown's avatar
unknown committed
403
{
unknown's avatar
unknown committed
404 405
  (void) hash_init(&hash_user_connections,system_charset_info,max_connections,
		   0,0,
406
		   (hash_get_key) get_key_conn, (hash_free_key) free_user,
407
		   0);
unknown's avatar
unknown committed
408 409 410
}


unknown's avatar
unknown committed
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
/*
  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
428 429
#ifndef NO_EMBEDDED_ACCESS_CHECKS

430
static int check_for_max_user_connections(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
431
{
432
  int error=0;
433
  DBUG_ENTER("check_for_max_user_connections");
unknown's avatar
unknown committed
434

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

  end:
455 456
  if (error)
    uc->connections--; // no need for decrease_user_connections() here
457
  (void) pthread_mutex_unlock(&LOCK_user_conn);
458
  DBUG_RETURN(error);
unknown's avatar
unknown committed
459
}
unknown's avatar
unknown committed
460
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
461

unknown's avatar
unknown committed
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
/*
  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.
*/

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

494

unknown's avatar
unknown committed
495 496 497 498 499
void free_max_user_conn(void)
{
  hash_free(&hash_user_connections);
}

unknown's avatar
unknown committed
500

501 502 503
/*
  Mark all commands that somehow changes a table
  This is used to check number of updates / hour
unknown's avatar
unknown committed
504 505 506

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

unknown's avatar
unknown committed
509
char  uc_update_queries[SQLCOM_END+1];
510 511 512

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

515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
  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;
534
  uc_update_queries[SQLCOM_UPDATE_MULTI]=1;
535 536
}

unknown's avatar
unknown committed
537 538
bool is_update_query(enum enum_sql_command command)
{
unknown's avatar
unknown committed
539
  DBUG_ASSERT(command >= 0 && command <= SQLCOM_END);
unknown's avatar
unknown committed
540 541
  return uc_update_queries[command];
}
542

unknown's avatar
unknown committed
543 544 545
/*
  Check if maximum queries per hour limit has been reached
  returns 0 if OK.
unknown's avatar
unknown committed
546

547 548 549
  In theory we would need a mutex in the USER_CONN structure for this to
  be 100 % safe, but as the worst scenario is that we would miss counting
  a couple of queries, this isn't critical.
unknown's avatar
unknown committed
550 551
*/

552

553
static bool check_mqh(THD *thd, uint check_command)
unknown's avatar
unknown committed
554
{
unknown's avatar
unknown committed
555 556 557
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return(0);
#else
unknown's avatar
unknown committed
558
  bool error=0;
unknown's avatar
unknown committed
559
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
560
  USER_CONN *uc=thd->user_connect;
unknown's avatar
unknown committed
561
  DBUG_ENTER("check_mqh");
562
  DBUG_ASSERT(uc != 0);
unknown's avatar
unknown committed
563

unknown's avatar
unknown committed
564
  /* If more than a hour since last check, reset resource checking */
565 566 567 568 569 570 571 572 573
  if (check_time  - uc->intime >= 3600)
  {
    (void) pthread_mutex_lock(&LOCK_user_conn);
    uc->questions=1;
    uc->updates=0;
    uc->conn_per_hour=0;
    uc->intime=check_time;
    (void) pthread_mutex_unlock(&LOCK_user_conn);
  }
unknown's avatar
unknown committed
574
  /* Check that we have not done too many questions / hour */
575 576 577
  if (uc->user_resources.questions &&
      uc->questions++ >= uc->user_resources.questions)
  {
578
    net_printf(thd, ER_USER_LIMIT_REACHED, uc->user, "max_questions",
579 580 581 582
	       (long) uc->user_resources.questions);
    error=1;
    goto end;
  }
583
  if (check_command < (uint) SQLCOM_END)
unknown's avatar
unknown committed
584
  {
unknown's avatar
unknown committed
585 586 587 588
    /* 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)
    {
589
      net_printf(thd, ER_USER_LIMIT_REACHED, uc->user, "max_updates",
unknown's avatar
unknown committed
590 591 592 593
		 (long) uc->user_resources.updates);
      error=1;
      goto end;
    }
unknown's avatar
unknown committed
594 595
  }
end:
596
  DBUG_RETURN(error);
unknown's avatar
unknown committed
597
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
598 599
}

unknown's avatar
unknown committed
600

unknown's avatar
unknown committed
601
static void reset_mqh(THD *thd, LEX_USER *lu, bool get_them= 0)
602
{
unknown's avatar
unknown committed
603
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
604
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
605
  if (lu)  // for GRANT
606
  {
607
    USER_CONN *uc;
608
    uint temp_len=lu->user.length+lu->host.length+2;
609 610
    char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];

unknown's avatar
unknown committed
611 612
    memcpy(temp_user,lu->user.str,lu->user.length);
    memcpy(temp_user+lu->user.length+1,lu->host.str,lu->host.length);
613
    temp_user[lu->user.length]='\0'; temp_user[temp_len-1]=0;
unknown's avatar
unknown committed
614
    if ((uc = (struct  user_conn *) hash_search(&hash_user_connections,
615
						(byte*) temp_user, temp_len)))
616 617
    {
      uc->questions=0;
618
      get_mqh(temp_user,&temp_user[lu->user.length+1],uc);
619 620
      uc->updates=0;
      uc->conn_per_hour=0;
621 622
    }
  }
623
  else // for FLUSH PRIVILEGES and FLUSH USER_RESOURCES
624
  {
unknown's avatar
unknown committed
625
    for (uint idx=0;idx < hash_user_connections.records; idx++)
626
    {
unknown's avatar
unknown committed
627 628
      USER_CONN *uc=(struct user_conn *) hash_element(&hash_user_connections,
						      idx);
629 630 631 632 633
      if (get_them)
	get_mqh(uc->user,uc->host,uc);
      uc->questions=0;
      uc->updates=0;
      uc->conn_per_hour=0;
634 635
    }
  }
unknown's avatar
unknown committed
636
  (void) pthread_mutex_unlock(&LOCK_user_conn);
unknown's avatar
unknown committed
637
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
638
}
unknown's avatar
unknown committed
639

unknown's avatar
unknown committed
640
/*
641
    Perform handshake, authorize client and update thd ACL variables.
642
  SYNOPSIS
643
    check_connection()
644
    thd  thread handle
645 646

  RETURN
647
     0  success, OK is sent to user, thd is updated.
648 649
    -1  error, which is sent to user
   > 0  error code (not sent to user)
unknown's avatar
unknown committed
650 651
*/

unknown's avatar
unknown committed
652 653
#ifndef EMBEDDED_LIBRARY
static int check_connection(THD *thd)
unknown's avatar
unknown committed
654
{
655
  uint connect_errors= 0;
unknown's avatar
unknown committed
656
  NET *net= &thd->net;
657

658 659 660
  DBUG_PRINT("info",
             ("New connection received on %s", vio_description(net->vio)));

unknown's avatar
unknown committed
661 662
  if (!thd->host)                           // If TCP/IP connection
  {
663
    char ip[30];
664

665
    if (vio_peer_addr(net->vio, ip, &thd->peer_port))
unknown's avatar
unknown committed
666
      return (ER_BAD_HOST_ERROR);
667
    if (!(thd->ip= my_strdup(ip,MYF(0))))
unknown's avatar
unknown committed
668
      return (ER_OUT_OF_RESOURCES);
669
    thd->host_or_ip= thd->ip;
unknown's avatar
unknown committed
670 671 672
#if !defined(HAVE_SYS_UN_H) || defined(HAVE_mit_thread)
    /* Fast local hostname resolve for Win32 */
    if (!strcmp(thd->ip,"127.0.0.1"))
unknown's avatar
unknown committed
673
    {
unknown's avatar
unknown committed
674 675
      thd->host= (char*) my_localhost;
      thd->host_or_ip= my_localhost;
unknown's avatar
unknown committed
676
    }
unknown's avatar
unknown committed
677 678 679
    else
#endif
    {
680 681 682 683 684 685
      if (!(specialflag & SPECIAL_NO_RESOLVE))
      {
	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)
unknown's avatar
unknown committed
686
	{
687
	  thd->host[min(strlen(thd->host), HOSTNAME_LENGTH)]= 0;
unknown's avatar
unknown committed
688 689
	  thd->host_or_ip= thd->host;
	}
690 691 692
	if (connect_errors > max_connect_errors)
	  return(ER_HOST_IS_BLOCKED);
      }
unknown's avatar
unknown committed
693
    }
unknown's avatar
unknown committed
694 695 696
    DBUG_PRINT("info",("Host: %s  ip: %s",
		       thd->host ? thd->host : "unknown host",
		       thd->ip ? thd->ip : "unknown ip"));
unknown's avatar
unknown committed
697 698 699
    if (acl_check_host(thd->host,thd->ip))
      return(ER_HOST_NOT_PRIVILEGED);
  }
700
  else /* Hostname given means that the connection was on a socket */
unknown's avatar
unknown committed
701
  {
unknown's avatar
unknown committed
702
    DBUG_PRINT("info",("Host: %s",thd->host));
703 704
    thd->host_or_ip= thd->host;
    thd->ip= 0;
705
    bzero((char*) &thd->remote, sizeof(struct sockaddr));
unknown's avatar
unknown committed
706 707
  }
  vio_keepalive(net->vio, TRUE);
708 709
  ulong pkt_len= 0;
  char *end;
unknown's avatar
unknown committed
710
  {
unknown's avatar
unknown committed
711
    /* buff[] needs to big enough to hold the server_version variable */
712
    char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH + 64];
713 714
    ulong client_flags = (CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB |
			  CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION);
unknown's avatar
unknown committed
715

716 717 718 719 720
    if (opt_using_transactions)
      client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS
    client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */
unknown's avatar
unknown committed
721 722 723 724
#ifdef HAVE_OPENSSL
    if (ssl_acceptor_fd)
      client_flags |= CLIENT_SSL;       /* Wow, SSL is avalaible! */
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
725

726 727 728 729 730 731 732 733 734 735 736
    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
737
      tail: that's why first part of the scramble is placed here, and second
738 739
      part at the end of packet.
    */
740
    end= strmake(end, thd->scramble, SCRAMBLE_LENGTH_323) + 1;
741 742 743
   
    int2store(end, client_flags);
    /* write server characteristics: up to 16 bytes allowed */
744
    end[2]=(char) default_charset_info->number;
745 746 747 748 749 750 751 752 753
    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
754
			  (uint) (end-buff)) ||
755
	(pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
756 757 758 759 760 761 762 763 764 765 766
	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
767
  if (thd->packet.alloc(thd->variables.net_buffer_length))
unknown's avatar
unknown committed
768 769 770
    return(ER_OUT_OF_RESOURCES);

  thd->client_capabilities=uint2korr(net->read_pos);
771 772 773 774 775 776 777 778 779 780 781
#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
782 783 784 785
  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
786 787 788 789 790 791 792
    DBUG_PRINT("info", ("client_character_set: %d", (uint) net->read_pos[8]));
    /*
      Use server character set and collation if
      - client has not specified a character set
      - client character set is the same as the servers
      - client character set doesn't exists in server
    */
793
    if (!(thd->variables.character_set_client=
unknown's avatar
unknown committed
794 795 796 797
	  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))
798
    {
799 800
      thd->variables.character_set_client=
	global_system_variables.character_set_client;
801 802
      thd->variables.collation_connection=
	global_system_variables.collation_connection;
803 804
      thd->variables.character_set_results=
	global_system_variables.character_set_results;
805 806 807
    }
    else
    {
808
      thd->variables.character_set_results=
809 810 811
      thd->variables.collation_connection= 
	thd->variables.character_set_client;
    }
unknown's avatar
unknown committed
812
    thd->update_charset();
813
    end= (char*) net->read_pos+32;
814 815 816 817 818 819 820
  }
  else
  {
    thd->max_client_packet_length= uint3korr(net->read_pos+2);
    end= (char*) net->read_pos+5;
  }

821
  if (thd->client_capabilities & CLIENT_IGNORE_SPACE)
822
    thd->variables.sql_mode|= MODE_IGNORE_SPACE;
unknown's avatar
unknown committed
823
#ifdef HAVE_OPENSSL
unknown's avatar
unknown committed
824
  DBUG_PRINT("info", ("client capabilities: %d", thd->client_capabilities));
unknown's avatar
unknown committed
825 826 827
  if (thd->client_capabilities & CLIENT_SSL)
  {
    /* Do the SSL layering. */
828 829 830 831 832
    if (!ssl_acceptor_fd)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
unknown's avatar
unknown committed
833
    DBUG_PRINT("info", ("IO layer change in progress..."));
unknown's avatar
unknown committed
834 835 836 837 838
    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
839
      return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
840
    }
unknown's avatar
unknown committed
841
    DBUG_PRINT("info", ("Reading user information over SSL layer"));
842
    if ((pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
843 844
	pkt_len < NORMAL_HANDSHAKE_SIZE)
    {
unknown's avatar
unknown committed
845 846
      DBUG_PRINT("error", ("Failed to read user information (pkt_len= %lu)",
			   pkt_len));
unknown's avatar
unknown committed
847 848 849 850
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
  }
851 852 853
#endif

  if (end >= (char*) net->read_pos+ pkt_len +2)
unknown's avatar
unknown committed
854
  {
855 856
    inc_host_errors(&thd->remote.sin_addr);
    return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
857 858 859
  }

  if (thd->client_capabilities & CLIENT_INTERACTIVE)
860
    thd->variables.net_wait_timeout= thd->variables.net_interactive_timeout;
861
  if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
862 863
      opt_using_transactions)
    net->return_status= &thd->server_status;
unknown's avatar
unknown committed
864
  net->read_timeout=(uint) thd->variables.net_read_timeout;
unknown's avatar
unknown committed
865

866 867
  char *user= end;
  char *passwd= strend(user)+1;
unknown's avatar
unknown committed
868
  char *db= passwd;
869
  char db_buff[NAME_LEN+1];                     // buffer to store db in utf8 
unknown's avatar
unknown committed
870
  char user_buff[USERNAME_LENGTH+1];		// buffer to store user in utf8
unknown's avatar
unknown committed
871 872 873 874 875 876 877 878 879
  /* 
    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'.
  */
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ? 
    *passwd++ : strlen(passwd);
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
unknown's avatar
unknown committed
880

unknown's avatar
unknown committed
881 882
  /* Since 4.1 all database names are stored in utf8 */
  if (db)
unknown's avatar
unknown committed
883
  {
884 885 886 887
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info,
                             db, strlen(db),
                             thd->charset())]= 0;
888
    db= db_buff;
unknown's avatar
unknown committed
889
  }
unknown's avatar
unknown committed
890

unknown's avatar
unknown committed
891 892 893 894 895 896 897 898
  if (user)
  {
    user_buff[copy_and_convert(user_buff, sizeof(user_buff)-1,
			       system_charset_info, user, strlen(user),
			       thd->charset())]= '\0';
    user= user_buff;
  }

899 900
  if (thd->user)
    x_free(thd->user);
901 902
  if (!(thd->user= my_strdup(user, MYF(0))))
    return (ER_OUT_OF_RESOURCES);
unknown's avatar
unknown committed
903
  return check_user(thd, COM_CONNECT, passwd, passwd_len, db, TRUE);
unknown's avatar
unknown committed
904 905
}

906

907 908
void execute_init_command(THD *thd, sys_var_str *init_command_var,
			  rw_lock_t *var_mutex)
unknown's avatar
unknown committed
909 910 911 912
{
  Vio* save_vio;
  ulong save_client_capabilities;

913 914 915 916 917 918 919 920 921
  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
922 923
  save_client_capabilities= thd->client_capabilities;
  thd->client_capabilities|= CLIENT_MULTI_QUERIES;
924 925 926 927
  /*
    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
928 929 930
  save_vio= thd->net.vio;
  thd->net.vio= 0;
  dispatch_command(COM_QUERY, thd, thd->query, thd->query_length+1);
931
  rw_unlock(var_mutex);
unknown's avatar
unknown committed
932 933 934 935 936
  thd->client_capabilities= save_client_capabilities;
  thd->net.vio= save_vio;
}


unknown's avatar
unknown committed
937 938 939 940
pthread_handler_decl(handle_one_connection,arg)
{
  THD *thd=(THD*) arg;
  uint launch_time  =
unknown's avatar
unknown committed
941
    (uint) ((thd->thr_create_time = time(NULL)) - thd->connect_time);
unknown's avatar
unknown committed
942 943 944 945 946
  if (launch_time >= slow_launch_time)
    statistic_increment(slow_launch_threads,&LOCK_status );

  pthread_detach_this_thread();

947 948
#if !defined( __WIN__) && !defined(OS2)	// Win32 calls this in pthread_create
  // The following calls needs to be done before we call DBUG_ macros
949
  if (!(test_flags & TEST_NO_THREADS) & my_thread_init())
unknown's avatar
unknown committed
950
  {
951
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
952
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
953 954 955 956 957
    end_thread(thd,0);
    return 0;
  }
#endif

958 959 960 961 962 963 964
  /*
    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
965 966 967 968
  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
969
#if defined(__WIN__)
unknown's avatar
unknown committed
970
  init_signals();				// IRENA; testing ?
unknown's avatar
unknown committed
971
#elif !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
972 973 974 975 976 977
  sigset_t set;
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
#endif
  if (thd->store_globals())
  {
978
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
979
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
980 981 982 983 984 985 986 987 988 989
    end_thread(thd,0);
    return 0;
  }

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

990
    if ((error=check_connection(thd)))
unknown's avatar
unknown committed
991 992
    {						// Wrong permissions
      if (error > 0)
993
	net_printf(thd,error,thd->host_or_ip);
unknown's avatar
unknown committed
994 995
#ifdef __NT__
      if (vio_type(net->vio) == VIO_TYPE_NAMEDPIPE)
996
	my_sleep(1000);				/* must wait after eof() */
unknown's avatar
unknown committed
997
#endif
998
      statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
999 1000
      goto end_thread;
    }
unknown's avatar
unknown committed
1001 1002 1003
#ifdef __NETWARE__
    netware_reg_user(thd->ip, thd->user, "MySQL");
#endif
1004
    if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1005 1006 1007 1008
      thd->options |= OPTION_BIG_SELECTS;
    if (thd->client_capabilities & CLIENT_COMPRESS)
      net->compress=1;				// Use compression

unknown's avatar
unknown committed
1009
    thd->version= refresh_version;
1010 1011 1012
    thd->proc_info= 0;
    thd->set_time();
    thd->init_for_queries();
unknown's avatar
unknown committed
1013
    if (sys_init_connect.value_length && !(thd->master_access & SUPER_ACL))
unknown's avatar
unknown committed
1014
    {
1015 1016 1017
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
	thd->killed= 1;
unknown's avatar
unknown committed
1018
    }
unknown's avatar
unknown committed
1019 1020 1021 1022 1023
    while (!net->error && net->vio != 0 && !thd->killed)
    {
      if (do_command(thd))
	break;
    }
1024 1025
    if (thd->user_connect)
      decrease_user_connections(thd->user_connect);
1026
    free_root(&thd->mem_root,MYF(0));
unknown's avatar
unknown committed
1027
    if (net->error && net->vio != 0 && net->report_error)
unknown's avatar
unknown committed
1028
    {
1029
      if (!thd->killed && thd->variables.log_warnings > 1)
unknown's avatar
unknown committed
1030 1031 1032 1033 1034 1035
        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)));
1036
      send_error(thd,net->last_errno,NullS);
unknown's avatar
unknown committed
1037
      statistic_increment(aborted_threads,&LOCK_status);
unknown's avatar
unknown committed
1038
    }
1039 1040 1041 1042
    else if (thd->killed)
    {
      statistic_increment(aborted_threads,&LOCK_status);
    }
1043
    
unknown's avatar
unknown committed
1044
end_thread:
1045
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
    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
1057 1058
#endif /* EMBEDDED_LIBRARY */

1059 1060 1061 1062
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
unknown's avatar
unknown committed
1063

1064
extern "C" pthread_handler_decl(handle_bootstrap,arg)
unknown's avatar
unknown committed
1065
{
1066 1067 1068
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
unknown's avatar
unknown committed
1069

1070
  /* The following must be called before DBUG_ENTER */
1071
  if (my_thread_init() || thd->store_globals())
unknown's avatar
unknown committed
1072
  {
unknown's avatar
unknown committed
1073
#ifndef EMBEDDED_LIBRARY
1074
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
1075
#endif
1076
    thd->fatal_error();
1077
    goto end;
unknown's avatar
unknown committed
1078
  }
1079 1080
  DBUG_ENTER("handle_bootstrap");

unknown's avatar
unknown committed
1081
#ifndef EMBEDDED_LIBRARY
1082 1083
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1084
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1085
  sigset_t set;
1086 1087
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
unknown's avatar
unknown committed
1088
#endif
unknown's avatar
unknown committed
1089
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
1090

1091
  if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1092 1093 1094 1095
    thd->options |= OPTION_BIG_SELECTS;

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

1098
  buff= (char*) thd->net.buff;
1099
  thd->init_for_queries();
unknown's avatar
unknown committed
1100 1101
  while (fgets(buff, thd->net.max_packet, file))
  {
unknown's avatar
unknown committed
1102
    uint length=(uint) strlen(buff);
1103 1104 1105 1106 1107 1108
    if (buff[length-1]!='\n' && !feof(file))
    {
      send_error(thd,ER_NET_PACKET_TOO_LARGE, NullS);
      thd->is_fatal_error= 1;
      break;
    }
unknown's avatar
unknown committed
1109
    while (length && (my_isspace(thd->charset(), buff[length-1]) ||
1110
           buff[length-1] == ';'))
unknown's avatar
unknown committed
1111 1112
      length--;
    buff[length]=0;
1113
    thd->query_length=length;
unknown's avatar
unknown committed
1114 1115
    thd->query= thd->memdup_w_gap(buff, length+1, thd->db_length+1);
    thd->query[length] = '\0';
unknown's avatar
unknown committed
1116
    thd->query_id=query_id++;
1117
    if (mqh_used && thd->user_connect && check_mqh(thd, SQLCOM_END))
1118 1119 1120 1121 1122 1123
    {
      thd->net.error = 0;
      close_thread_tables(thd);			// Free tables
      free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
      break;
    }
unknown's avatar
unknown committed
1124 1125
    mysql_parse(thd,thd->query,length);
    close_thread_tables(thd);			// Free tables
1126
    if (thd->is_fatal_error)
1127
      break;
1128
    free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
1129
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
unknown's avatar
unknown committed
1130
  }
1131 1132 1133

  /* thd->fatal_error should be set in case something went wrong */
end:
unknown's avatar
unknown committed
1134
#ifndef EMBEDDED_LIBRARY
1135 1136 1137
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1138
  (void) pthread_cond_broadcast(&COND_thread_count);
1139 1140
  my_thread_end();
  pthread_exit(0);
unknown's avatar
unknown committed
1141
#endif
1142
  DBUG_RETURN(0);				// Never reached
unknown's avatar
unknown committed
1143 1144
}

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

1147
void free_items(Item *item)
unknown's avatar
unknown committed
1148
{
1149
  for (; item ; item=item->next)
1150
    item->delete_self();
unknown's avatar
unknown committed
1151 1152
}

1153 1154 1155 1156 1157 1158 1159 1160
    /* 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
1161 1162 1163 1164 1165 1166 1167
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;
1168
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
1169
    DBUG_RETURN(1); // out of memory
unknown's avatar
unknown committed
1170
  table_list->db = db;
1171
  table_list->real_name = table_list->alias = tbl_name;
unknown's avatar
unknown committed
1172 1173 1174
  table_list->lock_type = TL_READ_NO_INSERT;
  table_list->next = 0;

1175 1176
  if (!db || check_db_name(db))
  {
1177
    net_printf(thd,ER_WRONG_DB_NAME, db ? db : "NULL");
1178 1179
    goto err;
  }
1180
  if (lower_case_table_names)
1181
    my_casedn_str(files_charset_info, tbl_name);
unknown's avatar
unknown committed
1182
  remove_escape(table_list->real_name);
1183 1184 1185 1186

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

unknown's avatar
unknown committed
1187
  if (check_one_table_access(thd, SELECT_ACL, table_list))
unknown's avatar
unknown committed
1188 1189
    goto err;
  thd->free_list = 0;
unknown's avatar
unknown committed
1190
  thd->query_length=(uint) strlen(tbl_name);
unknown's avatar
unknown committed
1191
  thd->query = tbl_name;
1192 1193
  if ((error = mysqld_dump_create_info(thd, table, -1)))
  {
1194
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1195 1196
    goto err;
  }
unknown's avatar
unknown committed
1197
  net_flush(&thd->net);
1198
  if ((error= table->file->dump(thd,fd)))
1199
    my_error(ER_GET_ERRNO, MYF(0), error);
unknown's avatar
unknown committed
1200

unknown's avatar
unknown committed
1201 1202
err:
  close_thread_tables(thd);
unknown's avatar
unknown committed
1203
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1204 1205 1206
}


1207
#ifndef EMBEDDED_LIBRARY
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218

/*
  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
1219 1220 1221
bool do_command(THD *thd)
{
  char *packet;
unknown's avatar
unknown committed
1222 1223
  uint old_timeout;
  ulong packet_length;
unknown's avatar
unknown committed
1224 1225 1226 1227 1228
  NET *net;
  enum enum_server_command command;
  DBUG_ENTER("do_command");

  net= &thd->net;
unknown's avatar
unknown committed
1229 1230 1231 1232
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1233
  thd->lex->current_select= 0;
unknown's avatar
unknown committed
1234 1235

  packet=0;
unknown's avatar
unknown committed
1236 1237 1238
  old_timeout=net->read_timeout;
  // Wait max for 8 hours
  net->read_timeout=(uint) thd->variables.net_wait_timeout;
unknown's avatar
unknown committed
1239
  thd->clear_error();				// Clear error message
unknown's avatar
unknown committed
1240 1241 1242 1243

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1244 1245 1246 1247 1248
    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)
1249 1250
    {
      statistic_increment(aborted_threads,&LOCK_status);
1251
      DBUG_RETURN(TRUE);			// We have to close it.
1252
    }
1253
    send_error(thd,net->last_errno,NullS);
1254
    net->error= 0;
1255
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
1256 1257 1258 1259 1260
  }
  else
  {
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1261 1262
    if (command >= COM_END)
      command= COM_END;				// Wrong command
unknown's avatar
unknown committed
1263 1264 1265
    DBUG_PRINT("info",("Command on %s = %d (%s)",
		       vio_description(net->vio), command,
		       command_name[command]));
unknown's avatar
unknown committed
1266
  }
unknown's avatar
unknown committed
1267
  net->read_timeout=old_timeout;		// restore it
1268 1269 1270 1271 1272 1273 1274 1275 1276
  /*
    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
1277
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1278
}
1279
#endif  /* EMBEDDED_LIBRARY */
1280

1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
/*
   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
*/
1296

1297 1298 1299 1300
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1301
  bool error= 0;
1302 1303 1304
  DBUG_ENTER("dispatch_command");

  thd->command=command;
unknown's avatar
unknown committed
1305 1306 1307 1308
  /*
    Commands which will always take a long time should be marked with
    this so that they will not get logged to the slow query log
  */
1309
  thd->slow_command=FALSE;
unknown's avatar
unknown committed
1310
  thd->set_time();
unknown's avatar
unknown committed
1311 1312 1313 1314 1315
  VOID(pthread_mutex_lock(&LOCK_thread_count));
  thd->query_id=query_id;
  if (command != COM_STATISTICS && command != COM_PING)
    query_id++;
  thread_running++;
1316
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
unknown's avatar
unknown committed
1317
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1318

1319 1320
  thd->server_status&=
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
1321
  switch (command) {
unknown's avatar
unknown committed
1322
  case COM_INIT_DB:
unknown's avatar
unknown committed
1323 1324 1325 1326 1327 1328 1329 1330 1331
  {
    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
1332
#ifdef HAVE_REPLICATION
1333 1334
  case COM_REGISTER_SLAVE:
  {
1335
    if (!register_slave(thd, (uchar*)packet, packet_length))
1336
      send_ok(thd);
1337 1338
    break;
  }
1339
#endif
unknown's avatar
unknown committed
1340
  case COM_TABLE_DUMP:
1341 1342 1343 1344 1345 1346
  {
    char *db, *tbl_name;
    uint db_len= *(uchar*) packet;
    uint tbl_len= *(uchar*) (packet + db_len + 1);

    statistic_increment(com_other, &LOCK_status);
1347
    thd->slow_command= TRUE;
1348 1349 1350 1351 1352 1353 1354
    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
1355 1356
  case COM_CHANGE_USER:
  {
unknown's avatar
unknown committed
1357
    thd->change_user();
1358
    thd->clear_error();                         // if errors from rollback
unknown's avatar
unknown committed
1359

1360 1361
    statistic_increment(com_other, &LOCK_status);
    char *user= (char*) packet;
unknown's avatar
unknown committed
1362
    char *passwd= strend(user)+1;
unknown's avatar
unknown committed
1363 1364 1365 1366 1367
    /* 
      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).
    */
1368
    char db_buff[NAME_LEN+1];                 // buffer to store db in utf8 
unknown's avatar
unknown committed
1369 1370 1371 1372
    char *db= passwd;
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ? 
      *passwd++ : strlen(passwd);
    db+= passwd_len + 1;
1373
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1374
    /* Small check for incomming packet */
unknown's avatar
unknown committed
1375
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1376 1377 1378 1379
    {
      send_error(thd, ER_UNKNOWN_COM_ERROR);
      break;
    }
1380
#endif
1381
    /* Convert database name to utf8 */
1382 1383 1384 1385
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
                             thd->charset())]= 0;
    db= db_buff;
unknown's avatar
unknown committed
1386

1387 1388 1389 1390 1391 1392 1393
    /* 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
1394
    USER_CONN *save_user_connect= thd->user_connect;
unknown's avatar
unknown committed
1395 1396
    
    if (!(thd->user= my_strdup(user, MYF(0))))
1397 1398 1399 1400 1401
    {
      thd->user= save_user;
      send_error(thd, ER_OUT_OF_RESOURCES);
      break;
    }
unknown's avatar
unknown committed
1402

unknown's avatar
unknown committed
1403 1404
    /* Clear variables that are allocated */
    thd->user_connect= 0;
unknown's avatar
unknown committed
1405
    int res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, FALSE);
unknown's avatar
unknown committed
1406

1407 1408 1409 1410 1411 1412 1413 1414
    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
1415
      thd->user_connect= save_user_connect;
1416 1417 1418 1419 1420 1421 1422 1423
      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
1424 1425
      if (save_user_connect)
	decrease_user_connections(save_user_connect);
1426 1427 1428
      x_free((gptr) save_db);
      x_free((gptr) save_user);
    }
unknown's avatar
unknown committed
1429 1430
    break;
  }
unknown's avatar
unknown committed
1431 1432
  case COM_EXECUTE:
  {
1433
    mysql_stmt_execute(thd, packet, packet_length);
unknown's avatar
unknown committed
1434 1435 1436 1437
    break;
  }
  case COM_LONG_DATA:
  {
1438
    mysql_stmt_get_longdata(thd, packet, packet_length);
unknown's avatar
unknown committed
1439 1440 1441 1442
    break;
  }
  case COM_PREPARE:
  {
1443
    mysql_stmt_prepare(thd, packet, packet_length);
unknown's avatar
unknown committed
1444 1445
    break;
  }
unknown's avatar
unknown committed
1446 1447 1448 1449 1450
  case COM_CLOSE_STMT:
  {
    mysql_stmt_free(thd, packet);
    break;
  }
1451 1452 1453 1454 1455
  case COM_RESET_STMT:
  {
    mysql_stmt_reset(thd, packet);
    break;
  }
unknown's avatar
unknown committed
1456 1457
  case COM_QUERY:
  {
1458 1459
    if (alloc_query(thd, packet, packet_length))
      break;					// fatal error is set
1460
    mysql_log.write(thd,command,"%s",thd->query);
1461
    DBUG_PRINT("query",("%-.4096s",thd->query));
1462
    mysql_parse(thd,thd->query, thd->query_length);
1463

1464
    while (!thd->killed && !thd->is_fatal_error && thd->lex->found_colon)
1465
    {
1466
      char *packet= thd->lex->found_colon;
1467
      /*
1468
        Multiple queries exits, execute them individually
1469
	in embedded server - just store them to be executed later 
1470
      */
1471
#ifndef EMBEDDED_LIBRARY
1472
      if (thd->lock || thd->open_tables || thd->derived_tables)
1473
        close_thread_tables(thd);
1474 1475
#endif
      ulong length= thd->query_length-(ulong)(packet-thd->query);
1476

1477
      /* Remove garbage at start of query */
unknown's avatar
unknown committed
1478
      while (my_isspace(thd->charset(), *packet) && length > 0)
1479 1480 1481 1482
      {
        packet++;
        length--;
      }
unknown's avatar
unknown committed
1483
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1484
      thd->query_length= length;
1485 1486
      thd->query= packet;
      thd->query_id= query_id++;
1487
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1488
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1489
#ifndef EMBEDDED_LIBRARY
1490
      mysql_parse(thd, packet, length);
1491
#else
unknown's avatar
unknown committed
1492 1493 1494 1495 1496 1497 1498 1499 1500 1501
      /*
	'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
1502
	thd->query_rest.copy(packet, length, thd->query_rest.charset());
1503 1504
      break;
#endif /*EMBEDDED_LIBRARY*/
1505 1506
    }

unknown's avatar
unknown committed
1507 1508 1509 1510 1511
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1512
  case COM_FIELD_LIST:				// This isn't actually needed
unknown's avatar
unknown committed
1513
#ifdef DONT_ALLOW_SHOW_COMMANDS
1514
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
1515 1516 1517
    break;
#else
  {
1518
    char *fields, *pend;
unknown's avatar
unknown committed
1519
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1520 1521
    LEX_STRING conv_name;

unknown's avatar
unknown committed
1522
    statistic_increment(com_stat[SQLCOM_SHOW_FIELDS],&LOCK_status);
unknown's avatar
unknown committed
1523 1524 1525
    bzero((char*) &table_list,sizeof(table_list));
    if (!(table_list.db=thd->db))
    {
1526
      send_error(thd,ER_NO_DB_ERROR);
unknown's avatar
unknown committed
1527 1528 1529
      break;
    }
    thd->free_list=0;
1530
    pend= strend(packet);
unknown's avatar
unknown committed
1531 1532 1533
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
    table_list.alias= table_list.real_name= conv_name.str;
1534
    packet= pend+1;
unknown's avatar
unknown committed
1535
    // command not cachable => no gap for data base name
unknown's avatar
unknown committed
1536 1537
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1538
    mysql_log.write(thd,command,"%s %s",table_list.real_name,fields);
1539
    if (lower_case_table_names)
unknown's avatar
unknown committed
1540
      my_casedn_str(files_charset_info, table_list.real_name);
unknown's avatar
unknown committed
1541 1542
    remove_escape(table_list.real_name);	// This can't have wildcards

unknown's avatar
unknown committed
1543 1544
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
		     0, 0))
unknown's avatar
unknown committed
1545
      break;
unknown's avatar
unknown committed
1546 1547
    if (grant_option &&
	check_grant(thd, SELECT_ACL, &table_list, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
1548 1549
      break;
    mysqld_list_fields(thd,&table_list,fields);
1550
    free_items(thd->free_list);
1551
    thd->free_list= 0;
unknown's avatar
unknown committed
1552 1553 1554 1555
    break;
  }
#endif
  case COM_QUIT:
1556
    /* We don't calculate statistics for this command */
1557
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1558 1559 1560 1561
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

unknown's avatar
unknown committed
1562
  case COM_CREATE_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1563
    {
unknown's avatar
unknown committed
1564 1565
      char *db=thd->strdup(packet), *alias;

unknown's avatar
unknown committed
1566
      statistic_increment(com_stat[SQLCOM_CREATE_DB],&LOCK_status);
1567
      // null test to handle EOM
unknown's avatar
unknown committed
1568
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1569
      {
1570
	net_printf(thd,ER_WRONG_DB_NAME, db ? db : "NULL");
1571 1572
	break;
      }
unknown's avatar
unknown committed
1573
      if (check_access(thd,CREATE_ACL,db,0,1,0))
unknown's avatar
unknown committed
1574
	break;
1575
      mysql_log.write(thd,command,packet);
unknown's avatar
unknown committed
1576
      mysql_create_db(thd,(lower_case_table_names == 2 ? alias : db),0,0);
unknown's avatar
unknown committed
1577 1578
      break;
    }
unknown's avatar
unknown committed
1579
  case COM_DROP_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1580
    {
unknown's avatar
unknown committed
1581
      statistic_increment(com_stat[SQLCOM_DROP_DB],&LOCK_status);
unknown's avatar
unknown committed
1582
      char *db=thd->strdup(packet), *alias;
1583
      // null test to handle EOM
unknown's avatar
unknown committed
1584
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1585
      {
1586
	net_printf(thd,ER_WRONG_DB_NAME, db ? db : "NULL");
1587 1588
	break;
      }
unknown's avatar
unknown committed
1589
      if (check_access(thd,DROP_ACL,db,0,1,0))
1590
	break;
unknown's avatar
unknown committed
1591 1592
      if (thd->locked_tables || thd->active_transaction())
      {
1593
	send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
unknown's avatar
unknown committed
1594
	break;
unknown's avatar
unknown committed
1595
      }
1596
      mysql_log.write(thd,command,db);
1597
      mysql_rm_db(thd, (lower_case_table_names == 2 ? alias : db), 0, 0);
unknown's avatar
unknown committed
1598 1599
      break;
    }
1600
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1601 1602
  case COM_BINLOG_DUMP:
    {
unknown's avatar
unknown committed
1603
      statistic_increment(com_other,&LOCK_status);
1604
      thd->slow_command = TRUE;
unknown's avatar
unknown committed
1605
      if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1606
	break;
1607
      mysql_log.write(thd,command, 0);
unknown's avatar
unknown committed
1608

unknown's avatar
unknown committed
1609 1610
      ulong pos;
      ushort flags;
1611
      uint32 slave_server_id;
1612
      /* TODO: The following has to be changed to an 8 byte integer */
1613 1614
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
unknown's avatar
unknown committed
1615
      thd->server_id=0; /* avoid suicide */
unknown's avatar
unknown committed
1616
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
unknown's avatar
unknown committed
1617
	kill_zombie_dump_threads(slave_server_id);
1618
      thd->server_id = slave_server_id;
1619
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
unknown's avatar
unknown committed
1620
      unregister_slave(thd,1,1);
1621 1622 1623
      // fake COM_QUIT -- if we get here, the thread needs to terminate
      error = TRUE;
      net->error = 0;
unknown's avatar
unknown committed
1624 1625
      break;
    }
1626
#endif
unknown's avatar
unknown committed
1627 1628
  case COM_REFRESH:
    {
unknown's avatar
unknown committed
1629
      statistic_increment(com_stat[SQLCOM_FLUSH],&LOCK_status);
unknown's avatar
unknown committed
1630
      ulong options= (ulong) (uchar) packet[0];
unknown's avatar
unknown committed
1631
      if (check_global_access(thd,RELOAD_ACL))
unknown's avatar
unknown committed
1632
	break;
1633
      mysql_log.write(thd,command,NullS);
1634 1635 1636 1637
      if (reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, NULL))
        send_error(thd, 0);
      else
        send_ok(thd);
unknown's avatar
unknown committed
1638 1639
      break;
    }
1640
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1641
  case COM_SHUTDOWN:
1642
  {
unknown's avatar
unknown committed
1643
    statistic_increment(com_other,&LOCK_status);
unknown's avatar
unknown committed
1644
    if (check_global_access(thd,SHUTDOWN_ACL))
unknown's avatar
unknown committed
1645
      break; /* purecov: inspected */
1646
    /*
1647 1648 1649 1650
      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].
1651
    */
1652 1653
    enum mysql_enum_shutdown_level level=
      (enum mysql_enum_shutdown_level) (uchar) packet[0];
1654
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1655 1656 1657 1658 1659 1660 1661 1662
    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;
    }
1663
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1664
    mysql_log.write(thd,command,NullS);
1665
    send_eof(thd);
unknown's avatar
unknown committed
1666 1667 1668
#ifdef __WIN__
    sleep(1);					// must wait after eof()
#endif
unknown's avatar
unknown committed
1669
#ifndef OS2
1670
    send_eof(thd);				// This is for 'quit request'
unknown's avatar
unknown committed
1671
#endif
1672
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1673
    close_thread_tables(thd);			// Free before kill
1674
    free_root(&thd->mem_root,MYF(0));
1675
    free_root(&thd->transaction.mem_root,MYF(0));
unknown's avatar
unknown committed
1676 1677 1678
    kill_mysql();
    error=TRUE;
    break;
1679
  }
1680
#endif
unknown's avatar
unknown committed
1681 1682
  case COM_STATISTICS:
  {
1683
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1684
    statistic_increment(com_stat[SQLCOM_SHOW_STATUS],&LOCK_status);
unknown's avatar
unknown committed
1685
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1686
    char buff[200];
unknown's avatar
unknown committed
1687 1688 1689
#else
    char *buff= thd->net.last_error;
#endif
1690
    ulong uptime = (ulong) (thd->start_time - start_time);
unknown's avatar
unknown committed
1691
    sprintf((char*) buff,
1692
	    "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
1693 1694 1695 1696 1697
	    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
1698
    if (sf_malloc_cur_memory)				// Using SAFEMALLOC
unknown's avatar
unknown committed
1699
      sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
1700 1701
	      (sf_malloc_cur_memory+1023L)/1024L,
	      (sf_malloc_max_memory+1023L)/1024L);
unknown's avatar
unknown committed
1702 1703
#endif
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1704
    VOID(my_net_write(net, buff,(uint) strlen(buff)));
unknown's avatar
unknown committed
1705
    VOID(net_flush(net));
unknown's avatar
unknown committed
1706
#endif
unknown's avatar
unknown committed
1707 1708 1709
    break;
  }
  case COM_PING:
unknown's avatar
unknown committed
1710
    statistic_increment(com_other,&LOCK_status);
1711
    send_ok(thd);				// Tell client we are alive
unknown's avatar
unknown committed
1712 1713
    break;
  case COM_PROCESS_INFO:
unknown's avatar
unknown committed
1714
    statistic_increment(com_stat[SQLCOM_SHOW_PROCESSLIST],&LOCK_status);
unknown's avatar
unknown committed
1715
    if (!thd->priv_user[0] && check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
1716
      break;
1717
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1718 1719
    mysqld_list_processes(thd,
			  thd->master_access & PROCESS_ACL ? 
unknown's avatar
unknown committed
1720
			  NullS : thd->priv_user, 0);
unknown's avatar
unknown committed
1721 1722 1723
    break;
  case COM_PROCESS_KILL:
  {
unknown's avatar
unknown committed
1724
    statistic_increment(com_stat[SQLCOM_KILL],&LOCK_status);
1725
    ulong id=(ulong) uint4korr(packet);
unknown's avatar
unknown committed
1726 1727 1728
    kill_one_thread(thd,id);
    break;
  }
1729 1730 1731 1732 1733 1734 1735
  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
1736
      send_eof(thd);
1737 1738 1739
      break;
    case MYSQL_OPTION_MULTI_STATEMENTS_OFF:
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
1740
      send_eof(thd);
1741 1742 1743 1744 1745 1746 1747
      break;
    default:
      send_error(thd, ER_UNKNOWN_COM_ERROR);
      break;
    }
    break;
  }
unknown's avatar
unknown committed
1748
  case COM_DEBUG:
unknown's avatar
unknown committed
1749
    statistic_increment(com_other,&LOCK_status);
unknown's avatar
unknown committed
1750
    if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
1751 1752
      break;					/* purecov: inspected */
    mysql_print_status(thd);
1753
    mysql_log.write(thd,command,NullS);
1754
    send_eof(thd);
unknown's avatar
unknown committed
1755 1756 1757 1758 1759
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
1760
  case COM_END:
unknown's avatar
unknown committed
1761
  default:
1762
    send_error(thd, ER_UNKNOWN_COM_ERROR);
unknown's avatar
unknown committed
1763 1764
    break;
  }
1765
  if (thd->lock || thd->open_tables || thd->derived_tables)
unknown's avatar
unknown committed
1766 1767 1768 1769 1770
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }

1771
  if (thd->is_fatal_error)
1772
    send_error(thd,0);				// End of memory ?
unknown's avatar
unknown committed
1773 1774

  time_t start_of_query=thd->start_time;
1775
  thd->end_time();				// Set start time
1776

1777
  /* If not reading from backup and if the query took too long */
1778
  if (!thd->slow_command && !thd->user_time) // do not log 'slow_command' queries
unknown's avatar
unknown committed
1779
  {
1780 1781
    thd->proc_info="logging slow query";

1782 1783
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
1784 1785
	((thd->server_status &
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
1786
	 (specialflag & SPECIAL_LOG_QUERIES_NOT_USING_INDEXES)))
1787 1788 1789 1790
    {
      long_query_count++;
      mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
    }
unknown's avatar
unknown committed
1791
  }
1792
  thd->proc_info="cleaning up";
unknown's avatar
unknown committed
1793 1794 1795 1796
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
  thd->proc_info=0;
  thd->command=COM_SLEEP;
  thd->query=0;
unknown's avatar
unknown committed
1797
  thd->query_length=0;
unknown's avatar
unknown committed
1798 1799
  thread_running--;
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1800
  thd->packet.shrink(thd->variables.net_buffer_length);	// Reclaim some memory
1801
  free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
unknown's avatar
unknown committed
1802 1803 1804
  DBUG_RETURN(error);
}

1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822

/*
  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
1823
  /* Remove garbage at start and end of query */
unknown's avatar
unknown committed
1824
  while (my_isspace(thd->charset(),packet[0]) && packet_length > 0)
1825 1826 1827 1828 1829
  {
    packet++;
    packet_length--;
  }
  char *pos=packet+packet_length;		// Point at end null
unknown's avatar
unknown committed
1830
  while (packet_length > 0 &&
unknown's avatar
unknown committed
1831
	 (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
1832 1833 1834 1835 1836
  {
    pos--;
    packet_length--;
  }
  /* We must allocate some extra memory for query cache */
unknown's avatar
unknown committed
1837
  thd->query_length= 0;                        // Extra safety: Avoid races
1838 1839
  if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
					      packet_length,
1840 1841
					      thd->db_length+ 1 +
					      QUERY_CACHE_FLAGS_SIZE)))
1842 1843 1844
    return 1;
  thd->query[packet_length]=0;
  thd->query_length= packet_length;
1845 1846 1847 1848

  /* Reclaim some memory */
  thd->packet.shrink(thd->variables.net_buffer_length);
  thd->convert_buffer.shrink(thd->variables.net_buffer_length);
1849 1850 1851 1852 1853 1854

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

unknown's avatar
unknown committed
1855 1856 1857 1858 1859 1860
/****************************************************************************
** mysql_execute_command
** Execute command saved in thd and current_lex->sql_command
****************************************************************************/

void
1861
mysql_execute_command(THD *thd)
unknown's avatar
unknown committed
1862
{
1863
  int	res= 0;
1864
  LEX	*lex= thd->lex;
1865
  TABLE_LIST *tables= (TABLE_LIST*) lex->select_lex.table_list.first;
unknown's avatar
unknown committed
1866
  SELECT_LEX *select_lex= &lex->select_lex;
1867
  SELECT_LEX_UNIT *unit= &lex->unit;
unknown's avatar
unknown committed
1868 1869
  DBUG_ENTER("mysql_execute_command");

1870 1871 1872 1873 1874 1875
  /*
    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.
  */
1876
  if (tables || &lex->select_lex != lex->all_selects_list)
1877 1878
    mysql_reset_errors(thd);

unknown's avatar
SCRUM  
unknown committed
1879
#ifdef HAVE_REPLICATION
1880 1881
  if (thd->slave_thread)
  {
unknown's avatar
unknown committed
1882
    /*
unknown's avatar
merge  
unknown committed
1883 1884 1885
      Skip if we are in the slave thread, some table rules have been
      given and the table list says the query should not be replicated
    */
1886
    if (all_tables_not_ok(thd,tables))
unknown's avatar
unknown committed
1887 1888 1889
    {
      /* we warn the slave SQL thread */
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
1890
      DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1891
    }
unknown's avatar
merge  
unknown committed
1892 1893
#ifndef TO_BE_DELETED
    /*
1894 1895 1896
      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
1897
    */
1898 1899 1900
    if (lex->sql_command == SQLCOM_SELECT)
    {
      lex->sql_command = SQLCOM_DO;
unknown's avatar
unknown committed
1901
      lex->insert_list = &select_lex->item_list;
1902
    }
unknown's avatar
merge  
unknown committed
1903
#endif
1904
  }
unknown's avatar
unknown committed
1905
#endif /* !HAVE_REPLICATION */
1906 1907
  if ((&lex->select_lex != lex->all_selects_list ||
       lex->time_zone_tables_used) &&
1908
      lex->unit.create_total_list(thd, lex, &tables))
1909
    DBUG_VOID_RETURN;
1910

1911 1912 1913 1914 1915
  /*
    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
1916
      !(thd->slave_thread || (thd->master_access & SUPER_ACL)) &&
1917 1918
      (uc_update_queries[lex->sql_command] > 0))
  {
unknown's avatar
unknown committed
1919
    net_printf(thd, ER_OPTION_PREVENTS_STATEMENT, "--read-only");
1920 1921
    DBUG_VOID_RETURN;
  }
1922

unknown's avatar
unknown committed
1923
  statistic_increment(com_stat[lex->sql_command],&LOCK_status);
unknown's avatar
unknown committed
1924 1925 1926
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
1927 1928 1929 1930 1931 1932 1933
    /* 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;
    }

1934
    select_result *result=lex->result;
unknown's avatar
unknown committed
1935 1936 1937 1938 1939
    if (tables)
    {
      res=check_table_access(thd,
			     lex->exchange ? SELECT_ACL | FILE_ACL :
			     SELECT_ACL,
unknown's avatar
unknown committed
1940
			     tables,0);
unknown's avatar
unknown committed
1941 1942 1943
    }
    else
      res=check_access(thd, lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
unknown's avatar
unknown committed
1944
		       any_db,0,0,0);
unknown's avatar
unknown committed
1945 1946 1947 1948 1949
    if (res)
    {
      res=0;
      break;					// Error message is given
    }
1950 1951 1952 1953
    /* 
       In case of single SELECT unit->global_parameters points on first SELECT
       TODO: move counters to SELECT_LEX
    */
1954 1955 1956
    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
1957
    if (unit->select_limit_cnt <
1958
	(ha_rows) unit->global_parameters->select_limit)
1959
      unit->select_limit_cnt= HA_POS_ERROR;		// no limit
1960
    if (unit->select_limit_cnt == HA_POS_ERROR && !select_lex->next_select())
1961
      select_lex->options&= ~OPTION_FOUND_ROWS;
unknown's avatar
unknown committed
1962 1963

    if (!(res=open_and_lock_tables(thd,tables)))
unknown's avatar
unknown committed
1964
    {
unknown's avatar
unknown committed
1965
      if (lex->describe)
unknown's avatar
unknown committed
1966
      {
1967 1968 1969 1970 1971 1972 1973
	if (!(result= new select_send()))
	{
	  send_error(thd, ER_OUT_OF_RESOURCES);
	  DBUG_VOID_RETURN;
	}
	else
	  thd->send_explain_fields(result);
1974
	res= mysql_explain_union(thd, &thd->lex->unit, result);
unknown's avatar
unknown committed
1975 1976 1977 1978 1979
	if (lex->describe & DESCRIBE_EXTENDED)
	{
	  char buff[1024];
	  String str(buff,(uint32) sizeof(buff), system_charset_info);
	  str.length(0);
1980
	  thd->lex->unit.print(&str);
unknown's avatar
unknown committed
1981 1982 1983 1984
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
1985
	result->send_eof();
1986
        delete result;
unknown's avatar
unknown committed
1987 1988 1989
      }
      else
      {
1990
	if (!result && !(result= new select_send()))
unknown's avatar
unknown committed
1991
	{
1992 1993
	  res= -1;
	  break;
unknown's avatar
unknown committed
1994
	}
unknown's avatar
unknown committed
1995
	query_cache_store_query(thd, tables);
1996 1997 1998
	res= handle_select(thd, lex, result);
        if (result != lex->result)
          delete result;
unknown's avatar
unknown committed
1999
      }
unknown's avatar
unknown committed
2000
    }
unknown's avatar
unknown committed
2001 2002
    break;
  }
unknown's avatar
unknown committed
2003
  case SQLCOM_PREPARE:
2004
  {
2005 2006 2007 2008
    char *query_str;
    uint query_len;
    if (lex->prepared_stmt_code_is_varref)
    {
2009
      /* This is PREPARE stmt FROM @var. */
2010 2011 2012 2013 2014
      String str;
      CHARSET_INFO *to_cs= thd->variables.collation_connection;
      bool need_conversion;
      user_var_entry *entry;
      uint32 unused;
2015
      /*
2016 2017 2018
        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.
2019
      */
2020 2021
      if ((entry=
             (user_var_entry*)hash_search(&thd->user_vars,
2022 2023 2024 2025
                                          (byte*)lex->prepared_stmt_code.str,
                                          lex->prepared_stmt_code.length))
          && entry->value)
      {
2026 2027 2028 2029 2030 2031 2032
        String *pstr;
        my_bool is_var_null;
        pstr= entry->val_str(&is_var_null, &str, NOT_FIXED_DEC);
        DBUG_ASSERT(!is_var_null);
        if (!pstr)
          send_error(thd, ER_OUT_OF_RESOURCES);
        DBUG_ASSERT(pstr == &str);
2033 2034
      }
      else
2035 2036 2037 2038 2039 2040
        str.set("NULL", 4, &my_charset_latin1);
      need_conversion=
        String::needs_conversion(str.length(), str.charset(), to_cs, &unused);

      query_len= need_conversion? (str.length() * to_cs->mbmaxlen) :
                                  str.length();
2041 2042
      if (!(query_str= alloc_root(&thd->mem_root, query_len+1)))
        send_error(thd, ER_OUT_OF_RESOURCES);
2043

2044
      if (need_conversion)
2045 2046
        query_len= copy_and_convert(query_str, query_len, to_cs, str.ptr(),
                                    str.length(), str.charset());
2047
      else
2048
        memcpy(query_str, str.ptr(), str.length());
2049
      query_str[query_len]= 0;
2050 2051 2052
    }
    else
    {
2053 2054
      query_str= lex->prepared_stmt_code.str;
      query_len= lex->prepared_stmt_code.length;
2055
      DBUG_PRINT("info", ("PREPARE: %.*s FROM '%.*s' \n",
2056 2057
                          lex->prepared_stmt_name.length,
                          lex->prepared_stmt_name.str,
2058
                          query_len, query_str));
2059
    }
unknown's avatar
unknown committed
2060
    thd->command= COM_PREPARE;
2061 2062
    if (!mysql_stmt_prepare(thd, query_str, query_len + 1,
                            &lex->prepared_stmt_name))
unknown's avatar
unknown committed
2063 2064 2065 2066 2067
      send_ok(thd, 0L, 0L, "Statement prepared");
    break;
  }
  case SQLCOM_EXECUTE:
  {
2068
    DBUG_PRINT("info", ("EXECUTE: %.*s\n",
2069 2070 2071
                        lex->prepared_stmt_name.length,
                        lex->prepared_stmt_name.str));
    mysql_sql_stmt_execute(thd, &lex->prepared_stmt_name);
unknown's avatar
unknown committed
2072 2073 2074 2075 2076
    lex->prepared_stmt_params.empty();
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2077 2078 2079 2080 2081
    Statement* stmt;
    DBUG_PRINT("info", ("DEALLOCATE PREPARE: %.*s\n", 
                        lex->prepared_stmt_name.length,
                        lex->prepared_stmt_name.str));
    if ((stmt= thd->stmt_map.find_by_name(&lex->prepared_stmt_name)))
unknown's avatar
unknown committed
2082
    {
2083 2084
      thd->stmt_map.erase(stmt);
      send_ok(thd);
unknown's avatar
unknown committed
2085
    }
2086
    else
2087 2088 2089 2090 2091 2092
    {
      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
2093 2094
    break;
  }
unknown's avatar
unknown committed
2095
  case SQLCOM_DO:
unknown's avatar
unknown committed
2096
    if (tables && ((res= check_table_access(thd, SELECT_ACL, tables,0)) ||
unknown's avatar
unknown committed
2097 2098 2099 2100 2101 2102
		   (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
2103 2104
    break;

2105
  case SQLCOM_EMPTY_QUERY:
2106
    send_ok(thd);
2107 2108
    break;

unknown's avatar
unknown committed
2109 2110 2111 2112
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2113
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2114
  case SQLCOM_PURGE:
2115
  {
unknown's avatar
unknown committed
2116
    if (check_global_access(thd, SUPER_ACL))
2117
      goto error;
2118
    // PURGE MASTER LOGS TO 'file'
2119 2120 2121
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2122 2123 2124 2125 2126 2127 2128 2129
  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;
  }
2130
#endif
unknown's avatar
unknown committed
2131 2132
  case SQLCOM_SHOW_WARNS:
  {
2133 2134
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2135 2136 2137
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
unknown's avatar
unknown committed
2138 2139 2140 2141
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2142 2143
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
unknown's avatar
unknown committed
2144 2145
    break;
  }
unknown's avatar
unknown committed
2146 2147
  case SQLCOM_SHOW_NEW_MASTER:
  {
unknown's avatar
unknown committed
2148
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2149
      goto error;
2150
    /* This query don't work now. See comment in repl_failsafe.cc */
unknown's avatar
unknown committed
2151
#ifndef WORKING_NEW_MASTER
2152
    net_printf(thd, ER_NOT_SUPPORTED_YET, "SHOW NEW MASTER");
unknown's avatar
unknown committed
2153 2154
    res= 1;
#else
unknown's avatar
unknown committed
2155
    res = show_new_master(thd);
unknown's avatar
unknown committed
2156
#endif
unknown's avatar
unknown committed
2157 2158
    break;
  }
2159

unknown's avatar
unknown committed
2160
#ifdef HAVE_REPLICATION
2161 2162
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
unknown's avatar
unknown committed
2163
    if (check_global_access(thd, REPL_SLAVE_ACL))
2164 2165 2166 2167
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
unknown's avatar
unknown committed
2168 2169
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
unknown's avatar
unknown committed
2170
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2171 2172 2173 2174
      goto error;
    res = show_binlog_events(thd);
    break;
  }
2175 2176
#endif

unknown's avatar
unknown committed
2177
  case SQLCOM_BACKUP_TABLE:
2178 2179
  {
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2180
	check_table_access(thd,SELECT_ACL, tables,0) ||
unknown's avatar
unknown committed
2181
	check_global_access(thd, FILE_ACL))
2182
      goto error; /* purecov: inspected */
2183
    thd->slow_command=TRUE;
2184
    res = mysql_backup_table(thd, tables);
unknown's avatar
unknown committed
2185

2186 2187
    break;
  }
unknown's avatar
unknown committed
2188
  case SQLCOM_RESTORE_TABLE:
2189 2190
  {
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2191
	check_table_access(thd, INSERT_ACL, tables,0) ||
unknown's avatar
unknown committed
2192
	check_global_access(thd, FILE_ACL))
2193
      goto error; /* purecov: inspected */
2194
    thd->slow_command=TRUE;
2195 2196 2197
    res = mysql_restore_table(thd, tables);
    break;
  }
unknown's avatar
unknown committed
2198 2199 2200
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
    if (check_db_used(thd, tables) ||
unknown's avatar
unknown committed
2201 2202
        check_access(thd, INDEX_ACL, tables->db,
                     &tables->grant.privilege, 0, 0))
unknown's avatar
unknown committed
2203
      goto error;
2204
    res= mysql_assign_to_keycache(thd, tables, &lex->name_and_length);
unknown's avatar
unknown committed
2205 2206
    break;
  }
unknown's avatar
unknown committed
2207 2208 2209
  case SQLCOM_PRELOAD_KEYS:
  {
    if (check_db_used(thd, tables) ||
unknown's avatar
unknown committed
2210 2211
	check_access(thd, INDEX_ACL, tables->db,
                     &tables->grant.privilege, 0, 0))
2212
      goto error;
unknown's avatar
unknown committed
2213 2214 2215
    res = mysql_preload_keys(thd, tables);
    break;
  }
unknown's avatar
unknown committed
2216
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2217
  case SQLCOM_CHANGE_MASTER:
2218
  {
unknown's avatar
unknown committed
2219
    if (check_global_access(thd, SUPER_ACL))
2220
      goto error;
2221
    pthread_mutex_lock(&LOCK_active_mi);
2222
    res = change_master(thd,active_mi);
2223
    pthread_mutex_unlock(&LOCK_active_mi);
2224 2225
    break;
  }
unknown's avatar
unknown committed
2226
  case SQLCOM_SHOW_SLAVE_STAT:
2227
  {
2228 2229
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2230
      goto error;
2231
    pthread_mutex_lock(&LOCK_active_mi);
2232
    res = show_master_info(thd,active_mi);
2233
    pthread_mutex_unlock(&LOCK_active_mi);
2234 2235
    break;
  }
unknown's avatar
unknown committed
2236
  case SQLCOM_SHOW_MASTER_STAT:
2237
  {
2238 2239
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2240 2241 2242 2243
      goto error;
    res = show_binlog_info(thd);
    break;
  }
unknown's avatar
unknown committed
2244

2245
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
unknown's avatar
unknown committed
2246
    if (check_global_access(thd, SUPER_ACL))
2247
      goto error;
2248 2249 2250 2251
    if (end_active_trans(thd))
      res= -1;
    else
      res = load_master_data(thd);
2252
    break;
unknown's avatar
unknown committed
2253
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
2254 2255 2256
#ifdef HAVE_INNOBASE_DB
  case SQLCOM_SHOW_INNODB_STATUS:
    {
2257
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2258 2259 2260 2261 2262
	goto error;
      res = innodb_show_status(thd);
      break;
    }
#endif
unknown's avatar
unknown committed
2263
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2264
  case SQLCOM_LOAD_MASTER_TABLE:
2265
  {
unknown's avatar
unknown committed
2266 2267
    if (!tables->db)
      tables->db=thd->db;
unknown's avatar
unknown committed
2268
    if (check_access(thd,CREATE_ACL,tables->db,&tables->grant.privilege,0,0))
unknown's avatar
unknown committed
2269 2270 2271 2272
      goto error;				/* purecov: inspected */
    if (grant_option)
    {
      /* Check that the first table has CREATE privilege */
unknown's avatar
unknown committed
2273
      if (check_grant(thd, CREATE_ACL, tables, 0, 1, 0))
2274
	goto error;
unknown's avatar
unknown committed
2275
    }
2276
    if (strlen(tables->real_name) > NAME_LEN)
unknown's avatar
unknown committed
2277
    {
2278
      net_printf(thd,ER_WRONG_TABLE_NAME, tables->real_name);
unknown's avatar
unknown committed
2279 2280
      break;
    }
2281
    pthread_mutex_lock(&LOCK_active_mi);
2282 2283 2284 2285
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
2286
    if (!fetch_master_table(thd, tables->db, tables->real_name,
2287
			    active_mi, 0, 0))
2288
    {
2289
      send_ok(thd);
2290
    }
2291
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2292
    break;
2293
  }
unknown's avatar
unknown committed
2294
#endif /* HAVE_REPLICATION */
2295

unknown's avatar
unknown committed
2296
  case SQLCOM_CREATE_TABLE:
unknown's avatar
unknown committed
2297
  {
unknown's avatar
unknown committed
2298
    /* Skip first table, which is the table we are creating */
2299 2300 2301
    TABLE_LIST *create_table, *create_table_local;
    tables= lex->unlink_first_table(tables, &create_table,
				    &create_table_local);
unknown's avatar
unknown committed
2302

unknown's avatar
unknown committed
2303 2304 2305
    if ((res= create_table_precheck(thd, tables, create_table)))
      goto unsent_create_error;

2306 2307 2308
#ifndef HAVE_READLINK
    lex->create_info.data_file_name=lex->create_info.index_file_name=0;
#else
2309
    /* Fix names if symlinked tables */
unknown's avatar
unknown committed
2310
    if (append_file_to_dir(thd, &lex->create_info.data_file_name,
unknown's avatar
unknown committed
2311
			   create_table->real_name) ||
unknown's avatar
unknown committed
2312
	append_file_to_dir(thd,&lex->create_info.index_file_name,
unknown's avatar
unknown committed
2313
			   create_table->real_name))
2314 2315
    {
      res=-1;
2316
      goto unsent_create_error;
2317
    }
2318
#endif
2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331
    /*
      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;
    }
2332
    if (select_lex->item_list.elements)		// With select
unknown's avatar
unknown committed
2333 2334 2335 2336
    {
      select_result *result;

      if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) &&
unknown's avatar
unknown committed
2337 2338
	  find_real_table_in_list(tables, create_table->db,
				  create_table->real_name))
unknown's avatar
unknown committed
2339
      {
unknown's avatar
unknown committed
2340
	net_printf(thd,ER_UPDATE_TABLE_USED, create_table->real_name);
2341
	goto create_error;
unknown's avatar
unknown committed
2342
      }
2343 2344 2345 2346 2347
      if (lex->create_info.used_fields & HA_CREATE_USED_UNION)
      {
        TABLE_LIST *tab;
        for (tab= tables; tab; tab= tab->next)
        {
2348 2349 2350
          if (find_real_table_in_list((TABLE_LIST*) lex->create_info.
                                      merge_list.first,
                                      tables->db, tab->real_name))
2351
          {
2352 2353
            net_printf(thd, ER_UPDATE_TABLE_USED, tab->real_name);
            goto create_error;
2354 2355 2356
          }
        }  
      }    
2357

unknown's avatar
unknown committed
2358
      if (tables && check_table_access(thd, SELECT_ACL, tables,0))
2359
	goto create_error;			// Error message is given
2360
      select_lex->options|= SELECT_NO_UNLOCK;
2361 2362 2363 2364
      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
2365
	unit->select_limit_cnt= HA_POS_ERROR;	// No limit
2366

unknown's avatar
unknown committed
2367
      if (!(res=open_and_lock_tables(thd,tables)))
2368
      {
unknown's avatar
unknown committed
2369 2370 2371 2372
	res= -1;				// If error
        if ((result=new select_create(create_table->db,
                                      create_table->real_name,
				      &lex->create_info,
2373 2374 2375
                                      lex->create_list,
                                      lex->key_list,
                                      select_lex->item_list,lex->duplicates)))
2376 2377 2378 2379 2380 2381
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
          select_lex->resolve_mode= SELECT_LEX::SELECT_MODE;
2382
          res=handle_select(thd, lex, result);
2383 2384
          select_lex->resolve_mode= SELECT_LEX::NOMATTER_MODE;
        }
2385 2386 2387
	//reset for PS
	lex->create_list.empty();
	lex->key_list.empty();
2388 2389
      }
    }
unknown's avatar
unknown committed
2390 2391
    else // regular create
    {
unknown's avatar
unknown committed
2392
      if (lex->name)
unknown's avatar
unknown committed
2393
        res= mysql_create_like_table(thd, create_table, &lex->create_info, 
unknown's avatar
unknown committed
2394 2395
                                     (Table_ident *)lex->name); 
      else
2396
      {
unknown's avatar
unknown committed
2397 2398
        res= mysql_create_table(thd,create_table->db,
			         create_table->real_name, &lex->create_info,
unknown's avatar
unknown committed
2399
			         lex->create_list,
2400
			         lex->key_list,0,0);
2401
      }
unknown's avatar
unknown committed
2402
      if (!res)
2403
	send_ok(thd);
unknown's avatar
unknown committed
2404
    }
2405

2406
    // put tables back for PS rexecuting
2407 2408
    tables= lex->link_first_table_back(tables, create_table,
				       create_table_local);
2409 2410
    break;

2411
create_error:
2412 2413 2414
    res= 1; //error reported
unsent_create_error:
    // put tables back for PS rexecuting
2415 2416
    tables= lex->link_first_table_back(tables, create_table,
				       create_table_local);
unknown's avatar
unknown committed
2417
    break;
unknown's avatar
unknown committed
2418
  }
unknown's avatar
unknown committed
2419
  case SQLCOM_CREATE_INDEX:
unknown's avatar
unknown committed
2420
    if (check_one_table_access(thd, INDEX_ACL, tables))
unknown's avatar
unknown committed
2421
      goto error; /* purecov: inspected */
2422
    thd->slow_command=TRUE;
2423 2424 2425 2426
    if (end_active_trans(thd))
      res= -1;
    else
      res = mysql_create_index(thd, tables, lex->key_list);
unknown's avatar
unknown committed
2427 2428
    break;

unknown's avatar
unknown committed
2429
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2430
  case SQLCOM_SLAVE_START:
2431
  {
2432
    pthread_mutex_lock(&LOCK_active_mi);
2433
    start_slave(thd,active_mi,1 /* net report*/);
2434
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2435
    break;
2436
  }
unknown's avatar
unknown committed
2437
  case SQLCOM_SLAVE_STOP:
2438 2439 2440 2441 2442 2443
  /*
    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,
2444
      so it waits for the client thread because t is locked by it.
2445
    - then the client thread does SLAVE STOP.
2446 2447
      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.
2448 2449 2450 2451 2452
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
  if (thd->locked_tables || thd->active_transaction())
  {
2453
    send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
unknown's avatar
unknown committed
2454
    break;
2455
  }
2456
  {
2457
    pthread_mutex_lock(&LOCK_active_mi);
2458
    stop_slave(thd,active_mi,1/* net report*/);
2459
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2460
    break;
2461
  }
unknown's avatar
unknown committed
2462
#endif /* HAVE_REPLICATION */
2463

unknown's avatar
unknown committed
2464 2465
  case SQLCOM_ALTER_TABLE:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
2466
    send_error(thd,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
unknown's avatar
unknown committed
2467 2468 2469
    break;
#else
    {
unknown's avatar
unknown committed
2470
      ulong priv=0;
unknown's avatar
unknown committed
2471
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
unknown's avatar
unknown committed
2472
      {
2473
	net_printf(thd, ER_WRONG_TABLE_NAME, lex->name);
unknown's avatar
unknown committed
2474 2475 2476
	res=0;
	break;
      }
2477 2478
      if (!select_lex->db)
	select_lex->db=tables->db;
unknown's avatar
unknown committed
2479 2480
      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
2481
	  check_merge_table_access(thd, tables->db,
2482 2483 2484
				   (TABLE_LIST *)
				   lex->create_info.merge_list.first))
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
2485 2486
      if (grant_option)
      {
unknown's avatar
unknown committed
2487
	if (check_grant(thd, ALTER_ACL, tables, 0, UINT_MAX, 0))
unknown's avatar
unknown committed
2488 2489 2490 2491 2492 2493
	  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;
2494
	  tmp_table.db=select_lex->db;
unknown's avatar
unknown committed
2495
	  tmp_table.grant.privilege=priv;
unknown's avatar
unknown committed
2496 2497
	  if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, 0,
			  UINT_MAX, 0))
unknown's avatar
unknown committed
2498 2499 2500
	    goto error;
	}
      }
2501 2502
      /* 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
2503
      /* ALTER TABLE ends previous transaction */
2504
      if (end_active_trans(thd))
unknown's avatar
unknown committed
2505 2506
	res= -1;
      else
unknown's avatar
unknown committed
2507
      {
2508
        thd->slow_command=TRUE;
2509
	res= mysql_alter_table(thd, select_lex->db, lex->name,
unknown's avatar
unknown committed
2510 2511
			       &lex->create_info,
			       tables, lex->create_list,
2512
			       lex->key_list,
2513
			       select_lex->order_list.elements,
2514
                               (ORDER *) select_lex->order_list.first,
2515
			       lex->duplicates, &lex->alter_info);
unknown's avatar
unknown committed
2516
      }
unknown's avatar
unknown committed
2517 2518
      break;
    }
unknown's avatar
unknown committed
2519
#endif /*DONT_ALLOW_SHOW_COMMANDS*/
unknown's avatar
unknown committed
2520
  case SQLCOM_RENAME_TABLE:
unknown's avatar
unknown committed
2521 2522 2523
  {
    TABLE_LIST *table;
    if (check_db_used(thd,tables))
unknown's avatar
unknown committed
2524
      goto error;
unknown's avatar
unknown committed
2525 2526
    for (table=tables ; table ; table=table->next->next)
    {
unknown's avatar
unknown committed
2527
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
unknown's avatar
unknown committed
2528
		       &table->grant.privilege,0,0) ||
unknown's avatar
unknown committed
2529
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next->db,
unknown's avatar
unknown committed
2530
		       &table->next->grant.privilege,0,0))
unknown's avatar
unknown committed
2531 2532 2533
	goto error;
      if (grant_option)
      {
unknown's avatar
unknown committed
2534
	TABLE_LIST old_list,new_list;
unknown's avatar
unknown committed
2535 2536 2537 2538
	/*
	  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
2539 2540 2541
	old_list=table[0];
	new_list=table->next[0];
	old_list.next=new_list.next=0;
unknown's avatar
unknown committed
2542
	if (check_grant(thd, ALTER_ACL, &old_list, 0, UINT_MAX, 0) ||
unknown's avatar
unknown committed
2543
	    (!test_all_bits(table->next->grant.privilege,
2544
			    INSERT_ACL | CREATE_ACL) &&
unknown's avatar
unknown committed
2545 2546
	     check_grant(thd, INSERT_ACL | CREATE_ACL, &new_list, 0,
			 UINT_MAX, 0)))
unknown's avatar
unknown committed
2547 2548 2549
	  goto error;
      }
    }
unknown's avatar
unknown committed
2550
    query_cache_invalidate3(thd, tables, 0);
2551 2552 2553
    if (end_active_trans(thd))
      res= -1;
    else if (mysql_rename_tables(thd,tables))
unknown's avatar
unknown committed
2554 2555
      res= -1;
    break;
unknown's avatar
unknown committed
2556
  }
2557
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2558 2559
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
2560
    send_error(thd,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
unknown's avatar
unknown committed
2561 2562 2563
    DBUG_VOID_RETURN;
#else
    {
unknown's avatar
unknown committed
2564
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2565 2566 2567 2568
	goto error;
      res = show_binlogs(thd);
      break;
    }
unknown's avatar
unknown committed
2569
#endif
2570
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
2571
  case SQLCOM_SHOW_CREATE:
unknown's avatar
unknown committed
2572
#ifdef DONT_ALLOW_SHOW_COMMANDS
2573
    send_error(thd,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
unknown's avatar
unknown committed
2574 2575
    DBUG_VOID_RETURN;
#else
unknown's avatar
unknown committed
2576
    {
unknown's avatar
unknown committed
2577 2578
      if (check_db_used(thd, tables) ||
	  check_access(thd, SELECT_ACL | EXTRA_ACL, tables->db,
unknown's avatar
unknown committed
2579
		       &tables->grant.privilege,0,0))
unknown's avatar
unknown committed
2580
	goto error;
unknown's avatar
unknown committed
2581
      res = mysqld_show_create(thd, tables);
unknown's avatar
unknown committed
2582 2583
      break;
    }
unknown's avatar
unknown committed
2584
#endif
2585 2586 2587
  case SQLCOM_CHECKSUM:
  {
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2588
	check_table_access(thd, SELECT_ACL | EXTRA_ACL , tables,0))
2589
      goto error; /* purecov: inspected */
2590
    res = mysql_checksum_table(thd, tables, &lex->check_opt);
2591 2592
    break;
  }
unknown's avatar
unknown committed
2593
  case SQLCOM_REPAIR:
2594 2595
  {
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2596
	check_table_access(thd,SELECT_ACL | INSERT_ACL, tables,0))
2597
      goto error; /* purecov: inspected */
2598
    thd->slow_command=TRUE;
2599
    res = mysql_repair_table(thd, tables, &lex->check_opt);
2600 2601 2602 2603 2604 2605 2606 2607 2608 2609
    /* ! 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())
      {
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
        mysql_bin_log.write(&qinfo);
      }
    }
2610 2611
    break;
  }
unknown's avatar
unknown committed
2612
  case SQLCOM_CHECK:
2613 2614
  {
    if (check_db_used(thd,tables) ||
2615
	check_table_access(thd, SELECT_ACL | EXTRA_ACL , tables,0))
2616
      goto error; /* purecov: inspected */
2617
    thd->slow_command=TRUE;
2618 2619 2620
    res = mysql_check_table(thd, tables, &lex->check_opt);
    break;
  }
unknown's avatar
unknown committed
2621 2622
  case SQLCOM_ANALYZE:
  {
unknown's avatar
unknown committed
2623
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2624
	check_table_access(thd,SELECT_ACL | INSERT_ACL, tables,0))
unknown's avatar
unknown committed
2625
      goto error; /* purecov: inspected */
2626
    thd->slow_command=TRUE;
2627
    res = mysql_analyze_table(thd, tables, &lex->check_opt);
2628 2629 2630 2631 2632 2633 2634 2635 2636 2637
    /* ! 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())
      {
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
        mysql_bin_log.write(&qinfo);
      }
    }
unknown's avatar
unknown committed
2638
    break;
unknown's avatar
unknown committed
2639
  }
2640

unknown's avatar
unknown committed
2641 2642
  case SQLCOM_OPTIMIZE:
  {
2643
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
2644
	check_table_access(thd,SELECT_ACL | INSERT_ACL, tables,0))
unknown's avatar
unknown committed
2645
      goto error; /* purecov: inspected */
2646
    thd->slow_command=TRUE;
2647 2648 2649
    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
      mysql_recreate_table(thd, tables, 1) :
      mysql_optimize_table(thd, tables, &lex->check_opt);
2650 2651 2652 2653 2654 2655 2656 2657 2658 2659
    /* ! 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())
      {
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
        mysql_bin_log.write(&qinfo);
      }
    }
unknown's avatar
unknown committed
2660 2661 2662
    break;
  }
  case SQLCOM_UPDATE:
unknown's avatar
unknown committed
2663 2664
    if (update_precheck(thd, tables))
      break;
2665 2666 2667 2668
    res= mysql_update(thd,tables,
                      select_lex->item_list,
                      lex->value_list,
                      select_lex->where,
2669
		      select_lex->order_list.elements,
2670 2671 2672
                      (ORDER *) select_lex->order_list.first,
                      select_lex->select_limit,
                      lex->duplicates);
unknown's avatar
unknown committed
2673 2674
    if (thd->net.report_error)
      res= -1;
2675 2676
    break;
  case SQLCOM_UPDATE_MULTI:
unknown's avatar
unknown committed
2677
  {
2678
    if ((res= multi_update_precheck(thd, tables)))
unknown's avatar
unknown committed
2679 2680 2681 2682 2683 2684 2685
      break;
    res= mysql_multi_update(thd,tables,
			    &select_lex->item_list,
			    &lex->value_list,
			    select_lex->where,
			    select_lex->options,
			    lex->duplicates, unit, select_lex);
unknown's avatar
unknown committed
2686
    break;
unknown's avatar
unknown committed
2687
  }
unknown's avatar
unknown committed
2688
  case SQLCOM_REPLACE:
2689 2690
  case SQLCOM_INSERT:
  {
2691
    if ((res= insert_precheck(thd, tables)))
unknown's avatar
unknown committed
2692
      break;
unknown's avatar
unknown committed
2693
    res = mysql_insert(thd,tables,lex->field_list,lex->many_values,
2694
                       select_lex->item_list, lex->value_list,
2695
                       lex->duplicates);
unknown's avatar
unknown committed
2696 2697
    if (thd->net.report_error)
      res= -1;
unknown's avatar
unknown committed
2698
    break;
2699
  }
unknown's avatar
unknown committed
2700 2701 2702
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
2703 2704 2705
    TABLE_LIST *first_local_table= (TABLE_LIST *) select_lex->table_list.first;
    if ((res= insert_select_precheck(thd, tables)))
      break;
unknown's avatar
unknown committed
2706

2707 2708
    /* Fix lock for first table */
    if (tables->lock_type == TL_WRITE_DELAYED)
2709
      tables->lock_type= TL_WRITE;
2710

2711 2712
    /* Don't unlock tables until command is written to binary log */
    select_lex->options|= SELECT_NO_UNLOCK;
unknown's avatar
unknown committed
2713 2714

    select_result *result;
2715 2716 2717 2718
    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
2719

2720
    if (find_real_table_in_list(tables->next, tables->db, tables->real_name))
2721
    {
2722 2723
      /* Using same table for INSERT and SELECT */
      select_lex->options |= OPTION_BUFFER_RESULT;
unknown's avatar
unknown committed
2724
    }
2725

unknown's avatar
unknown committed
2726

2727 2728 2729
    if (!(res= open_and_lock_tables(thd, tables)) &&
        (result= new select_insert(tables->table, &lex->field_list,
                                   lex->duplicates)))
2730
    {
2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742
      /* Skip first table, which is the table we are inserting in */
      lex->select_lex.table_list.first= (byte*) first_local_table->next;
      /*
        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.table_list.first= (byte*) first_local_table;
      lex->select_lex.resolve_mode= SELECT_LEX::INSERT_MODE;
      delete result;
unknown's avatar
unknown committed
2743
      if (thd->net.report_error)
2744
        res= -1;
2745 2746 2747
    }
    else
      res= -1;
unknown's avatar
unknown committed
2748 2749
    break;
  }
2750
  case SQLCOM_TRUNCATE:
unknown's avatar
unknown committed
2751
    if (check_one_table_access(thd, DELETE_ACL, tables))
unknown's avatar
unknown committed
2752
      goto error;
2753 2754 2755 2756 2757 2758
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
    if (thd->locked_tables || thd->active_transaction())
    {
2759
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION,NullS);
2760 2761
      goto error;
    }
2762
    res=mysql_truncate(thd, tables, 0);
2763
    break;
unknown's avatar
unknown committed
2764
  case SQLCOM_DELETE:
unknown's avatar
unknown committed
2765
  {
unknown's avatar
unknown committed
2766 2767
    if ((res= delete_precheck(thd, tables)))
      break;
unknown's avatar
unknown committed
2768
    res = mysql_delete(thd,tables, select_lex->where,
2769
                       &select_lex->order_list,
unknown's avatar
unknown committed
2770
                       select_lex->select_limit, select_lex->options);
unknown's avatar
unknown committed
2771 2772
    if (thd->net.report_error)
      res= -1;
unknown's avatar
unknown committed
2773 2774
    break;
  }
2775
  case SQLCOM_DELETE_MULTI:
unknown's avatar
unknown committed
2776
  {
2777 2778
    TABLE_LIST *aux_tables=
      (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
unknown's avatar
unknown committed
2779 2780
    TABLE_LIST *target_tbl;
    uint table_count;
unknown's avatar
unknown committed
2781
    multi_delete *result;
unknown's avatar
unknown committed
2782

2783 2784
    if ((res= multi_delete_precheck(thd, tables, &table_count)))
      break;
unknown's avatar
unknown committed
2785

unknown's avatar
unknown committed
2786
    /* condition will be TRUE on SP re-excuting */
2787 2788
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
unknown's avatar
unknown committed
2789
    if (add_item_to_list(thd, new Item_null()))
2790
    {
unknown's avatar
unknown committed
2791
      res= -1;
2792
      break;
unknown's avatar
unknown committed
2793
    }
2794

unknown's avatar
unknown committed
2795 2796 2797 2798
    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
2799 2800 2801
    for (target_tbl= (TABLE_LIST*) aux_tables;
	 target_tbl;
	 target_tbl= target_tbl->next)
unknown's avatar
unknown committed
2802
    {
2803 2804 2805
      TABLE_LIST *orig= target_tbl->table_list;
      target_tbl->table= orig->table;
      /*
unknown's avatar
unknown committed
2806
	 Multi-delete can't be constructed over-union => we always have
unknown's avatar
unknown committed
2807
	 single SELECT on top and have to check underlying SELECTs of it
2808
      */
2809 2810
      if (lex->select_lex.check_updateable_in_subqueries(orig->db,
                                                         orig->real_name))
2811
      {
2812 2813 2814 2815
        my_error(ER_UPDATE_TABLE_USED, MYF(0),
                 orig->real_name);
        res= -1;
        break;
2816
      }
unknown's avatar
unknown committed
2817
    }
2818

2819 2820
    if (!thd->is_fatal_error && (result= new multi_delete(thd,aux_tables,
							  table_count)))
unknown's avatar
unknown committed
2821
    {
2822 2823 2824
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
2825
			select_lex->item_list,
unknown's avatar
unknown committed
2826
			select_lex->where,
2827
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
unknown's avatar
unknown committed
2828 2829
			(ORDER *)NULL,
			select_lex->options | thd->options |
unknown's avatar
unknown committed
2830
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK,
2831
			result, unit, select_lex);
unknown's avatar
unknown committed
2832 2833
      if (thd->net.report_error)
	res= -1;
2834
      delete result;
unknown's avatar
unknown committed
2835 2836 2837 2838 2839 2840
    }
    else
      res= -1;					// Error is not sent
    close_thread_tables(thd);
    break;
  }
unknown's avatar
unknown committed
2841
  case SQLCOM_DROP_TABLE:
unknown's avatar
unknown committed
2842
  {
2843 2844
    if (!lex->drop_temporary)
    {
unknown's avatar
unknown committed
2845
      if (check_table_access(thd,DROP_ACL,tables,0))
2846 2847 2848 2849 2850 2851 2852
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
unknown's avatar
unknown committed
2853
    else
unknown's avatar
unknown committed
2854 2855 2856 2857 2858 2859
    {
      /*
	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
2860 2861
	To not generate such irrelevant "table does not exist errors",
	we silently add IF EXISTS if TEMPORARY was used.
unknown's avatar
unknown committed
2862 2863 2864 2865
      */
      if (thd->slave_thread)
	lex->drop_if_exists= 1;
    }
2866
    res= mysql_rm_table(thd,tables,lex->drop_if_exists, lex->drop_temporary);
unknown's avatar
unknown committed
2867 2868
  }
  break;
unknown's avatar
unknown committed
2869
  case SQLCOM_DROP_INDEX:
unknown's avatar
unknown committed
2870
    if (check_one_table_access(thd, INDEX_ACL, tables))
unknown's avatar
unknown committed
2871
      goto error;				/* purecov: inspected */
2872 2873 2874
    if (end_active_trans(thd))
      res= -1;
    else
2875
      res = mysql_drop_index(thd, tables, &lex->alter_info);
unknown's avatar
unknown committed
2876 2877
    break;
  case SQLCOM_SHOW_DATABASES:
2878
#if defined(DONT_ALLOW_SHOW_COMMANDS)
2879
    send_error(thd,ER_NOT_ALLOWED_COMMAND);   /* purecov: inspected */
unknown's avatar
unknown committed
2880 2881 2882
    DBUG_VOID_RETURN;
#else
    if ((specialflag & SPECIAL_SKIP_SHOW_DB) &&
unknown's avatar
unknown committed
2883
	check_global_access(thd, SHOW_DB_ACL))
unknown's avatar
unknown committed
2884 2885 2886 2887 2888
      goto error;
    res= mysqld_show_dbs(thd, (lex->wild ? lex->wild->ptr() : NullS));
    break;
#endif
  case SQLCOM_SHOW_PROCESSLIST:
unknown's avatar
unknown committed
2889
    if (!thd->priv_user[0] && check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
2890
      break;
unknown's avatar
unknown committed
2891 2892
    mysqld_list_processes(thd,
			  thd->master_access & PROCESS_ACL ? NullS :
unknown's avatar
unknown committed
2893
			  thd->priv_user,lex->verbose);
unknown's avatar
unknown committed
2894
    break;
unknown's avatar
unknown committed
2895 2896
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
unknown's avatar
unknown committed
2897 2898 2899 2900 2901 2902 2903
    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
2904
  case SQLCOM_SHOW_STATUS:
2905
    res= mysqld_show(thd,(lex->wild ? lex->wild->ptr() : NullS),status_vars,
2906
		     OPT_GLOBAL, &LOCK_status);
unknown's avatar
unknown committed
2907 2908 2909
    break;
  case SQLCOM_SHOW_VARIABLES:
    res= mysqld_show(thd, (lex->wild ? lex->wild->ptr() : NullS),
2910 2911
		     init_vars, lex->option_type,
		     &LOCK_global_system_variables);
unknown's avatar
unknown committed
2912
    break;
unknown's avatar
unknown committed
2913 2914
  case SQLCOM_SHOW_LOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
2915
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
2916 2917 2918
    DBUG_VOID_RETURN;
#else
    {
unknown's avatar
unknown committed
2919
      if (grant_option && check_access(thd, FILE_ACL, any_db,0,0,0))
unknown's avatar
unknown committed
2920 2921 2922 2923 2924
	goto error;
      res= mysqld_show_logs(thd);
      break;
    }
#endif
unknown's avatar
unknown committed
2925
  case SQLCOM_SHOW_TABLES:
2926
    /* FALL THROUGH */
unknown's avatar
unknown committed
2927
#ifdef DONT_ALLOW_SHOW_COMMANDS
2928
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
2929 2930 2931
    DBUG_VOID_RETURN;
#else
    {
2932
      char *db=select_lex->db ? select_lex->db : thd->db;
unknown's avatar
unknown committed
2933 2934
      if (!db)
      {
2935
	send_error(thd,ER_NO_DB_ERROR);	/* purecov: inspected */
unknown's avatar
unknown committed
2936 2937 2938
	goto error;				/* purecov: inspected */
      }
      remove_escape(db);				// Fix escaped '_'
2939
      if (check_db_name(db))
unknown's avatar
unknown committed
2940
      {
2941
        net_printf(thd,ER_WRONG_DB_NAME, db);
2942
        goto error;
unknown's avatar
unknown committed
2943
      }
unknown's avatar
unknown committed
2944
      if (check_access(thd,SELECT_ACL,db,&thd->col_access,0,0))
unknown's avatar
unknown committed
2945
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
2946
      if (!thd->col_access && check_grant_db(thd,db))
unknown's avatar
unknown committed
2947
      {
unknown's avatar
unknown committed
2948
	net_printf(thd, ER_DBACCESS_DENIED_ERROR,
unknown's avatar
unknown committed
2949 2950 2951 2952 2953
		   thd->priv_user,
		   thd->priv_host,
		   db);
	goto error;
      }
unknown's avatar
unknown committed
2954
      /* grant is checked in mysqld_show_tables */
2955
      if (lex->describe)
2956
        res= mysqld_extend_show_tables(thd,db,
2957
				       (lex->wild ? lex->wild->ptr() : NullS));
unknown's avatar
unknown committed
2958 2959 2960 2961 2962 2963
      else
	res= mysqld_show_tables(thd,db,
				(lex->wild ? lex->wild->ptr() : NullS));
      break;
    }
#endif
2964 2965 2966
  case SQLCOM_SHOW_OPEN_TABLES:
    res= mysqld_show_open_tables(thd,(lex->wild ? lex->wild->ptr() : NullS));
    break;
2967 2968
  case SQLCOM_SHOW_CHARSETS:
    res= mysqld_show_charsets(thd,(lex->wild ? lex->wild->ptr() : NullS));
2969
    break;
2970 2971 2972
  case SQLCOM_SHOW_COLLATIONS:
    res= mysqld_show_collations(thd,(lex->wild ? lex->wild->ptr() : NullS));
    break;
unknown's avatar
unknown committed
2973 2974
  case SQLCOM_SHOW_FIELDS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
2975
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
2976 2977 2978
    DBUG_VOID_RETURN;
#else
    {
2979
      char *db=tables->db;
unknown's avatar
unknown committed
2980
      remove_escape(db);			// Fix escaped '_'
2981
      remove_escape(tables->real_name);
2982
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
unknown's avatar
unknown committed
2983
		       &tables->grant.privilege, 0, 0))
unknown's avatar
unknown committed
2984
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
2985
      if (grant_option && check_grant(thd, SELECT_ACL, tables, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
2986 2987
	goto error;
      res= mysqld_show_fields(thd,tables,
unknown's avatar
unknown committed
2988 2989
			      (lex->wild ? lex->wild->ptr() : NullS),
			      lex->verbose);
unknown's avatar
unknown committed
2990 2991 2992 2993 2994
      break;
    }
#endif
  case SQLCOM_SHOW_KEYS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
2995
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
2996 2997 2998
    DBUG_VOID_RETURN;
#else
    {
2999
      char *db=tables->db;
unknown's avatar
unknown committed
3000
      remove_escape(db);			// Fix escaped '_'
3001
      remove_escape(tables->real_name);
unknown's avatar
unknown committed
3002
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
unknown's avatar
unknown committed
3003
		       &tables->grant.privilege, 0, 0))
unknown's avatar
unknown committed
3004
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
3005
      if (grant_option && check_grant(thd, SELECT_ACL, tables, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
3006 3007 3008 3009 3010 3011
	goto error;
      res= mysqld_show_keys(thd,tables);
      break;
    }
#endif
  case SQLCOM_CHANGE_DB:
3012
    mysql_change_db(thd,select_lex->db);
unknown's avatar
unknown committed
3013
    break;
3014

unknown's avatar
unknown committed
3015 3016 3017
  case SQLCOM_LOAD:
  {
    uint privilege= (lex->duplicates == DUP_REPLACE ?
3018
		     INSERT_ACL | DELETE_ACL : INSERT_ACL);
3019 3020

    if (!lex->local_file)
unknown's avatar
unknown committed
3021
    {
unknown's avatar
unknown committed
3022
      if (check_access(thd,privilege | FILE_ACL,tables->db,0,0,0))
unknown's avatar
unknown committed
3023 3024 3025 3026
	goto error;
    }
    else
    {
3027
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
unknown's avatar
unknown committed
3028
	  ! opt_local_infile)
3029
      {
3030
	send_error(thd,ER_NOT_ALLOWED_COMMAND);
3031 3032
	goto error;
      }
unknown's avatar
unknown committed
3033
      if (check_one_table_access(thd, privilege, tables))
unknown's avatar
unknown committed
3034 3035 3036 3037 3038 3039
	goto error;
    }
    res=mysql_load(thd, lex->exchange, tables, lex->field_list,
		   lex->duplicates, (bool) lex->local_file, lex->lock_option);
    break;
  }
3040

unknown's avatar
unknown committed
3041
  case SQLCOM_SET_OPTION:
3042 3043
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
unknown's avatar
unknown committed
3044
    if (tables && ((res= check_table_access(thd, SELECT_ACL, tables,0)) ||
unknown's avatar
unknown committed
3045 3046
		   (res= open_and_lock_tables(thd,tables))))
      break;
3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060
    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;
3061
      send_ok(thd);
3062
    }
unknown's avatar
unknown committed
3063 3064
    if (thd->net.report_error)
      res= -1;
unknown's avatar
unknown committed
3065
    break;
3066
  }
unknown's avatar
unknown committed
3067

unknown's avatar
unknown committed
3068
  case SQLCOM_UNLOCK_TABLES:
unknown's avatar
unknown committed
3069
    unlock_locked_tables(thd);
unknown's avatar
unknown committed
3070 3071
    if (thd->options & OPTION_TABLE_LOCK)
    {
unknown's avatar
unknown committed
3072
      end_active_trans(thd);
unknown's avatar
unknown committed
3073
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3074 3075
    }
    if (thd->global_read_lock)
3076
      unlock_global_read_lock(thd);
3077
    send_ok(thd);
unknown's avatar
unknown committed
3078 3079
    break;
  case SQLCOM_LOCK_TABLES:
unknown's avatar
unknown committed
3080
    unlock_locked_tables(thd);
3081
    if (check_db_used(thd,tables) || end_active_trans(thd))
unknown's avatar
unknown committed
3082
      goto error;
unknown's avatar
unknown committed
3083
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, tables,0))
3084
      goto error;
unknown's avatar
unknown committed
3085
    thd->in_lock_tables=1;
unknown's avatar
unknown committed
3086
    thd->options|= OPTION_TABLE_LOCK;
3087
    if (!(res= open_and_lock_tables(thd, tables)))
unknown's avatar
unknown committed
3088
    {
3089 3090 3091 3092
#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
3093 3094
      thd->locked_tables=thd->lock;
      thd->lock=0;
3095
      send_ok(thd);
unknown's avatar
unknown committed
3096
    }
unknown's avatar
unknown committed
3097 3098
    else
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3099 3100 3101
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3102
  {
unknown's avatar
unknown committed
3103
    char *alias;
unknown's avatar
unknown committed
3104
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3105
    {
3106
      net_printf(thd,ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
3107 3108
      break;
    }
3109 3110 3111 3112 3113 3114 3115
    /*
      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.
    */
3116
#ifdef HAVE_REPLICATION
3117 3118 3119
    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
3120 3121
    {
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
3122
      break;
unknown's avatar
unknown committed
3123
    }
3124
#endif
unknown's avatar
unknown committed
3125
    if (check_access(thd,CREATE_ACL,lex->name,0,1,0))
3126
      break;
unknown's avatar
unknown committed
3127
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : lex->name),
unknown's avatar
unknown committed
3128
			 &lex->create_info, 0);
3129 3130
    break;
  }
unknown's avatar
unknown committed
3131
  case SQLCOM_DROP_DB:
3132
  {
unknown's avatar
unknown committed
3133
    char *alias;
unknown's avatar
unknown committed
3134
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3135
    {
3136
      net_printf(thd, ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
3137 3138
      break;
    }
3139 3140 3141 3142 3143 3144 3145
    /*
      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.
    */
3146
#ifdef HAVE_REPLICATION
3147 3148 3149
    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
3150 3151
    {
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
3152
      break;
unknown's avatar
unknown committed
3153
    }
3154
#endif
unknown's avatar
unknown committed
3155
    if (check_access(thd,DROP_ACL,lex->name,0,1,0))
3156
      break;
3157 3158
    if (thd->locked_tables || thd->active_transaction())
    {
3159
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
3160 3161
      goto error;
    }
3162 3163
    res=mysql_rm_db(thd, (lower_case_table_names == 2 ? alias : lex->name),
                    lex->drop_if_exists, 0);
3164 3165
    break;
  }
3166 3167 3168 3169
  case SQLCOM_ALTER_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3170
      net_printf(thd, ER_WRONG_DB_NAME, lex->name);
3171 3172
      break;
    }
unknown's avatar
unknown committed
3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188
    /*
      If in a slave thread :
      ALTER 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.
    */
#ifdef HAVE_REPLICATION
    if (thd->slave_thread && 
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
    {
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
      break;
    }
#endif
unknown's avatar
unknown committed
3189
    if (check_access(thd,ALTER_ACL,lex->name,0,1,0))
3190 3191 3192
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
3193
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
3194 3195
      goto error;
    }
3196
    res=mysql_alter_db(thd,lex->name,&lex->create_info);
3197 3198
    break;
  }
unknown's avatar
unknown committed
3199 3200 3201 3202
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3203
      net_printf(thd,ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
3204 3205
      break;
    }
unknown's avatar
unknown committed
3206
    if (check_access(thd,SELECT_ACL,lex->name,0,1,0))
unknown's avatar
unknown committed
3207 3208 3209
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
3210
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
unknown's avatar
unknown committed
3211 3212
      goto error;
    }
unknown's avatar
unknown committed
3213
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
unknown's avatar
unknown committed
3214 3215
    break;
  }
unknown's avatar
unknown committed
3216
  case SQLCOM_CREATE_FUNCTION:
unknown's avatar
unknown committed
3217
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0))
unknown's avatar
unknown committed
3218 3219 3220
      break;
#ifdef HAVE_DLOPEN
    if (!(res = mysql_create_function(thd,&lex->udf)))
3221
      send_ok(thd);
unknown's avatar
unknown committed
3222 3223 3224 3225 3226
#else
    res= -1;
#endif
    break;
  case SQLCOM_DROP_FUNCTION:
unknown's avatar
unknown committed
3227
    if (check_access(thd,DELETE_ACL,"mysql",0,1,0))
unknown's avatar
unknown committed
3228 3229
      break;
#ifdef HAVE_DLOPEN
3230
    if (!(res = mysql_drop_function(thd,&lex->udf.name)))
3231
      send_ok(thd);
unknown's avatar
unknown committed
3232 3233 3234 3235
#else
    res= -1;
#endif
    break;
unknown's avatar
unknown committed
3236
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3237 3238
  case SQLCOM_DROP_USER:
  {
unknown's avatar
unknown committed
3239
    if (check_access(thd, GRANT_ACL,"mysql",0,1,0))
3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254
      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())
      {
	Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
	mysql_bin_log.write(&qinfo);
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
unknown's avatar
unknown committed
3255
    if (check_access(thd, GRANT_ACL ,"mysql",0,1,0))
3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268
      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())
      {
	Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
	mysql_bin_log.write(&qinfo);
      }
      send_ok(thd);
    }
    break;
  }
3269 3270 3271 3272 3273 3274
  case SQLCOM_REVOKE:
  case SQLCOM_GRANT:
  {
    if (check_access(thd, lex->grant | lex->grant_tot_col | GRANT_ACL,
		     tables && tables->db ? tables->db : select_lex->db,
		     tables ? &tables->grant.privilege : 0,
unknown's avatar
unknown committed
3275
		     tables ? 0 : 1,0))
3276 3277
      goto error;

unknown's avatar
unknown committed
3278 3279 3280 3281
    /*
      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
    */
3282 3283 3284 3285 3286 3287 3288 3289 3290 3291

    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
3292
	     my_strcasecmp(&my_charset_latin1,
3293
                           user->host.str, thd->host_or_ip)))
3294
	{
unknown's avatar
unknown committed
3295
	  if (check_access(thd, UPDATE_ACL, "mysql",0,1,0))
3296 3297 3298 3299 3300
	    goto error;
	  break;			// We are allowed to do changes
	}
      }
    }
unknown's avatar
SCRUM  
unknown committed
3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313
    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);
      }
    }
3314 3315 3316 3317 3318
    if (tables)
    {
      if (grant_option && check_grant(thd,
				      (lex->grant | lex->grant_tot_col |
				       GRANT_ACL),
unknown's avatar
unknown committed
3319
				      tables, 0, UINT_MAX, 0))
3320
	goto error;
unknown's avatar
unknown committed
3321 3322 3323
      if (!(res = mysql_table_grant(thd,tables,lex->users_list, lex->columns,
				    lex->grant,
				    lex->sql_command == SQLCOM_REVOKE)))
3324
      {
3325
	mysql_update_log.write(thd, thd->query, thd->query_length);
3326 3327
	if (mysql_bin_log.is_open())
	{
unknown's avatar
unknown committed
3328
          thd->clear_error();
3329
	  Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
3330 3331 3332 3333 3334 3335 3336 3337
	  mysql_bin_log.write(&qinfo);
	}
      }
    }
    else
    {
      if (lex->columns.elements)
      {
3338
	send_error(thd,ER_ILLEGAL_GRANT_FOR_TABLE);
3339 3340 3341 3342 3343 3344 3345
	res=1;
      }
      else
	res = mysql_grant(thd, select_lex->db, lex->users_list, lex->grant,
			  lex->sql_command == SQLCOM_REVOKE);
      if (!res)
      {
3346
	mysql_update_log.write(thd, thd->query, thd->query_length);
3347 3348
	if (mysql_bin_log.is_open())
	{
unknown's avatar
unknown committed
3349
          thd->clear_error();
3350
	  Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
3351 3352
	  mysql_bin_log.write(&qinfo);
	}
3353
	if (mqh_used && lex->sql_command == SQLCOM_GRANT)
3354
	{
unknown's avatar
unknown committed
3355 3356 3357
	  List_iterator <LEX_USER> str_list(lex->users_list);
	  LEX_USER *user;
	  while ((user=str_list++))
3358
	    reset_mqh(thd,user);
3359
	}
3360 3361 3362 3363
      }
    }
    break;
  }
unknown's avatar
SCRUM  
unknown committed
3364
#endif /*!NO_EMBEDDED_ACCESS_CHECKS*/
unknown's avatar
unknown committed
3365
  case SQLCOM_RESET:
3366 3367 3368 3369 3370 3371 3372
    /* 
       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
3373
    if (check_global_access(thd,RELOAD_ACL) || check_db_used(thd, tables))
unknown's avatar
unknown committed
3374
      goto error;
3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398
    /*
      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())
        {
          Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
          mysql_bin_log.write(&qinfo);
        }
      }
      send_ok(thd);
    }
unknown's avatar
unknown committed
3399
    break;
3400
  }
unknown's avatar
unknown committed
3401 3402 3403
  case SQLCOM_KILL:
    kill_one_thread(thd,lex->thread_id);
    break;
unknown's avatar
unknown committed
3404
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
3405 3406
  case SQLCOM_SHOW_GRANTS:
    res=0;
3407 3408
    if ((thd->priv_user &&
	 !strcmp(thd->priv_user,lex->grant_user->user.str)) ||
unknown's avatar
unknown committed
3409
	!check_access(thd, SELECT_ACL, "mysql",0,1,0))
unknown's avatar
unknown committed
3410 3411 3412 3413
    {
      res = mysql_show_grants(thd,lex->grant_user);
    }
    break;
unknown's avatar
unknown committed
3414
#endif
3415
  case SQLCOM_HA_OPEN:
3416
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
3417
	check_table_access(thd,SELECT_ACL, tables,0))
3418 3419 3420 3421 3422 3423 3424 3425 3426
      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:
3427 3428 3429 3430 3431
    /*
      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
3432
    if (check_db_used(thd,tables))
3433
      goto error;
unknown's avatar
unknown committed
3434
    res = mysql_ha_read(thd, tables, lex->ha_read_mode, lex->backup_dir,
3435 3436
			lex->insert_list, lex->ha_rkey_mode, select_lex->where,
			select_lex->select_limit, select_lex->offset_limit);
3437 3438
    break;

unknown's avatar
unknown committed
3439
  case SQLCOM_BEGIN:
unknown's avatar
unknown committed
3440 3441 3442 3443 3444 3445
    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
3446 3447 3448 3449 3450 3451
    if (end_active_trans(thd))
    {
      res= -1;
    }
    else
    {
3452
      thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
unknown's avatar
unknown committed
3453 3454
		     OPTION_BEGIN);
      thd->server_status|= SERVER_STATUS_IN_TRANS;
3455
      send_ok(thd);
unknown's avatar
unknown committed
3456
    }
unknown's avatar
unknown committed
3457 3458
    break;
  case SQLCOM_COMMIT:
3459 3460 3461 3462 3463
    /*
      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
3464
  {
3465
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
3466 3467
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
    if (!ha_commit(thd))
unknown's avatar
unknown committed
3468
    {
3469
      send_ok(thd);
unknown's avatar
unknown committed
3470
    }
unknown's avatar
unknown committed
3471 3472 3473
    else
      res= -1;
    break;
unknown's avatar
unknown committed
3474
  }
unknown's avatar
unknown committed
3475 3476 3477
  case SQLCOM_ROLLBACK:
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
    if (!ha_rollback(thd))
3478
    {
unknown's avatar
unknown committed
3479 3480 3481 3482 3483 3484 3485 3486 3487 3488
      /*
        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)
3489
	send_warning(thd,ER_WARNING_NOT_COMPLETE_ROLLBACK,0);
3490
      else
3491
	send_ok(thd);
3492
    }
unknown's avatar
unknown committed
3493 3494
    else
      res= -1;
3495
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
3496
    break;
unknown's avatar
unknown committed
3497 3498 3499
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
    if (!ha_rollback_to_savepoint(thd, lex->savepoint_name))
    {
unknown's avatar
unknown committed
3500
      if ((thd->options & OPTION_STATUS_NO_TRANS_UPDATE) && !thd->slave_thread)
unknown's avatar
unknown committed
3501
	send_warning(thd, ER_WARNING_NOT_COMPLETE_ROLLBACK, 0);
unknown's avatar
unknown committed
3502
      else
unknown's avatar
unknown committed
3503
	send_ok(thd);
unknown's avatar
unknown committed
3504 3505 3506 3507
    }
    else
      res= -1;
    break;
3508
  case SQLCOM_SAVEPOINT:
unknown's avatar
unknown committed
3509
    if (!ha_savepoint(thd, lex->savepoint_name))
unknown's avatar
unknown committed
3510
      send_ok(thd);
unknown's avatar
unknown committed
3511 3512
    else
      res= -1;
3513
    break;
unknown's avatar
unknown committed
3514
  default:					/* Impossible */
3515
    send_ok(thd);
unknown's avatar
unknown committed
3516 3517 3518
    break;
  }
  thd->proc_info="query end";			// QQ
3519
  if (thd->one_shot_set)
unknown's avatar
unknown committed
3520 3521 3522 3523 3524 3525 3526 3527
  {
    /*
      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 (lex->sql_command != SQLCOM_SET_OPTION)
3528
    {
unknown's avatar
unknown committed
3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540
      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;
3541
    }
unknown's avatar
unknown committed
3542
  }
unknown's avatar
unknown committed
3543
  if (res < 0)
3544
    send_error(thd,thd->killed ? ER_SERVER_SHUTDOWN : 0);
unknown's avatar
unknown committed
3545 3546 3547 3548 3549 3550

error:
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
3551 3552 3553 3554
/*
  Check grants for commands which work only with one table and all other
  tables belong to subselects.

3555
  SYNOPSIS
unknown's avatar
unknown committed
3556 3557 3558 3559
    check_one_table_access()
    thd			Thread handler
    privilege		requested privelage
    tables		table list of command
unknown's avatar
unknown committed
3560 3561 3562

  RETURN
    0 - OK
unknown's avatar
unknown committed
3563
    1 - access denied, error is sent to client
unknown's avatar
unknown committed
3564
*/
unknown's avatar
unknown committed
3565 3566

int check_one_table_access(THD *thd, ulong privilege, TABLE_LIST *tables)
unknown's avatar
unknown committed
3567
{
unknown's avatar
unknown committed
3568 3569
  if (check_access(thd, privilege, tables->db, &tables->grant.privilege,0,0))
    return 1;
unknown's avatar
unknown committed
3570

unknown's avatar
unknown committed
3571
  /* Show only 1 table for check_grant */
unknown's avatar
unknown committed
3572
  if (grant_option && check_grant(thd, privilege, tables, 0, 1, 0))
unknown's avatar
unknown committed
3573
    return 1;
unknown's avatar
unknown committed
3574

unknown's avatar
unknown committed
3575
  /* Check rights on tables of subselect (if exists) */
unknown's avatar
unknown committed
3576 3577
  TABLE_LIST *subselects_tables;
  if ((subselects_tables= tables->next))
unknown's avatar
unknown committed
3578
  {
unknown's avatar
unknown committed
3579
    if ((check_table_access(thd, SELECT_ACL, subselects_tables,0)))
unknown's avatar
unknown committed
3580 3581 3582
      return 1;
  }
  return 0;
unknown's avatar
unknown committed
3583 3584 3585
}


unknown's avatar
unknown committed
3586
/****************************************************************************
unknown's avatar
unknown committed
3587
  Get the user (global) and database privileges for all used tables
unknown's avatar
unknown committed
3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600

  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
3601 3602
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
unknown's avatar
unknown committed
3603 3604 3605
****************************************************************************/

bool
unknown's avatar
unknown committed
3606
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
3607
	     bool dont_check_global_grants, bool no_errors)
unknown's avatar
unknown committed
3608
{
unknown's avatar
unknown committed
3609 3610 3611
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("want_access: %lu  master_access: %lu", want_access,
		      thd->master_access));
unknown's avatar
unknown committed
3612 3613 3614 3615
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
#endif
  ulong dummy;
unknown's avatar
unknown committed
3616 3617 3618 3619 3620
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

3621
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
unknown's avatar
unknown committed
3622
  {
3623
    if (!no_errors)
3624
      send_error(thd,ER_NO_DB_ERROR);	/* purecov: tested */
unknown's avatar
unknown committed
3625
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
3626 3627
  }

unknown's avatar
unknown committed
3628 3629 3630
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
unknown's avatar
unknown committed
3631 3632
  if ((thd->master_access & want_access) == want_access)
  {
3633 3634 3635 3636 3637 3638 3639 3640
    /*
      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) &&
	(db && (!thd->db || strcmp(db,thd->db))))
3641
      db_access=acl_get(thd->host, thd->ip,
3642
			thd->priv_user, db, test(want_access & GRANT_ACL));
3643
    *save_priv=thd->master_access | db_access;
unknown's avatar
unknown committed
3644
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
3645
  }
3646
  if (((want_access & ~thd->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
3647
      ! db && dont_check_global_grants)
unknown's avatar
unknown committed
3648
  {						// We can never grant this
3649
    if (!no_errors)
3650
      net_printf(thd,ER_ACCESS_DENIED_ERROR,
3651
		 thd->priv_user,
3652
		 thd->priv_host,
3653
		 thd->password ? ER(ER_YES) : ER(ER_NO));/* purecov: tested */
unknown's avatar
unknown committed
3654
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
3655 3656 3657
  }

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

unknown's avatar
unknown committed
3660
  if (db && (!thd->db || strcmp(db,thd->db)))
3661
    db_access=acl_get(thd->host, thd->ip,
3662
		      thd->priv_user, db, test(want_access & GRANT_ACL));
unknown's avatar
unknown committed
3663 3664
  else
    db_access=thd->db_access;
3665 3666
  // Remove SHOW attribute and access rights we already have
  want_access &= ~(thd->master_access | EXTRA_ACL);
unknown's avatar
unknown committed
3667
  db_access= ((*save_priv=(db_access | thd->master_access)) & want_access);
3668 3669

  /* grant_option is set if there exists a single table or column grant */
unknown's avatar
unknown committed
3670
  if (db_access == want_access ||
3671
      ((grant_option && !dont_check_global_grants) &&
3672
       !(want_access & ~(db_access | TABLE_ACLS))))
unknown's avatar
unknown committed
3673
    DBUG_RETURN(FALSE);				/* Ok */
3674
  if (!no_errors)
3675
    net_printf(thd,ER_DBACCESS_DENIED_ERROR,
3676
	       thd->priv_user,
3677
	       thd->priv_host,
3678
	       db ? db : thd->db ? thd->db : "unknown"); /* purecov: tested */
unknown's avatar
unknown committed
3679
  DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
3680
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
3681 3682 3683
}


3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701
/*
  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
3702 3703

bool check_global_access(THD *thd, ulong want_access)
unknown's avatar
unknown committed
3704
{
unknown's avatar
unknown committed
3705 3706 3707
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
unknown's avatar
unknown committed
3708
  char command[128];
3709
  if ((thd->master_access & want_access))
unknown's avatar
unknown committed
3710 3711
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
3712
  net_printf(thd,ER_SPECIFIC_ACCESS_DENIED_ERROR,
unknown's avatar
unknown committed
3713 3714
	     command);
  return 1;
unknown's avatar
unknown committed
3715
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
3716 3717 3718
}


unknown's avatar
unknown committed
3719
/*
unknown's avatar
unknown committed
3720 3721
  Check the privilege for all used tables.  Table privileges are cached
  in the table list for GRANT checking
unknown's avatar
unknown committed
3722 3723
*/

3724
bool
unknown's avatar
unknown committed
3725
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
3726
		   bool no_errors)
unknown's avatar
unknown committed
3727
{
unknown's avatar
unknown committed
3728 3729
  uint found=0;
  ulong found_access=0;
unknown's avatar
unknown committed
3730 3731 3732
  TABLE_LIST *org_tables=tables;
  for (; tables ; tables=tables->next)
  {
3733
    if (tables->derived || (tables->table && (int)tables->table->tmp_table))
unknown's avatar
unknown committed
3734
      continue;
unknown's avatar
unknown committed
3735 3736
    if ((thd->master_access & want_access) == (want_access & ~EXTRA_ACL) &&
	thd->db)
unknown's avatar
unknown committed
3737
      tables->grant.privilege= want_access;
unknown's avatar
unknown committed
3738
    else if (tables->db && tables->db == thd->db)
unknown's avatar
unknown committed
3739 3740 3741 3742 3743
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
3744 3745
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
			 0, no_errors))
unknown's avatar
unknown committed
3746 3747
	  return TRUE;				// Access denied
	found_access=tables->grant.privilege;
unknown's avatar
unknown committed
3748
	found=1;
unknown's avatar
unknown committed
3749 3750
      }
    }
3751
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
3752
			  0, no_errors))
3753
      return TRUE;
unknown's avatar
unknown committed
3754 3755
  }
  if (grant_option)
3756
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
unknown's avatar
unknown committed
3757
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
unknown's avatar
unknown committed
3758 3759 3760
  return FALSE;
}

3761 3762
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
3763 3764 3765 3766
{
  int error=0;
  if (table_list)
  {
3767
    /* Check that all tables use the current database */
3768 3769
    TABLE_LIST *tmp;
    for (tmp=table_list; tmp ; tmp=tmp->next)
3770 3771 3772 3773
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
3774
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
unknown's avatar
unknown committed
3775
			     table_list,0);
3776 3777 3778 3779
  }
  return error;
}

unknown's avatar
unknown committed
3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795

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

unknown's avatar
unknown committed
3797 3798 3799 3800 3801 3802 3803 3804 3805 3806
/****************************************************************************
	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
3807 3808 3809 3810
#ifndef DBUG_OFF
long max_stack_used;
#endif

3811
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
3812 3813 3814 3815 3816 3817 3818 3819
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));
3820
    thd->fatal_error();
unknown's avatar
unknown committed
3821 3822
    return 1;
  }
unknown's avatar
unknown committed
3823 3824 3825
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
unknown's avatar
unknown committed
3826 3827
  return 0;
}
3828
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
3829 3830 3831 3832

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

3833
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
unknown's avatar
unknown committed
3834 3835
{
  LEX	*lex=current_lex;
3836
  ulong old_info=0;
unknown's avatar
unknown committed
3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861
  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;
}

/****************************************************************************
3862
  Initialize global thd variables needed for query
unknown's avatar
unknown committed
3863 3864
****************************************************************************/

3865
void
unknown's avatar
unknown committed
3866
mysql_init_query(THD *thd, uchar *buf, uint length)
unknown's avatar
unknown committed
3867 3868
{
  DBUG_ENTER("mysql_init_query");
unknown's avatar
unknown committed
3869
  lex_start(thd, buf, length);
3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890
  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");
3891
  thd->free_list= 0;
3892 3893
  thd->select_number= 1;
  thd->total_warn_count= 0;                     // Warnings for this query
unknown's avatar
unknown committed
3894 3895
  thd->last_insert_id_used= thd->query_start_used= thd->insert_id_used=0;
  thd->sent_row_count= thd->examined_row_count= 0;
3896
  thd->is_fatal_error= thd->rand_used= thd->time_zone_used= 0;
unknown's avatar
unknown committed
3897 3898 3899
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
			  SERVER_QUERY_NO_INDEX_USED |
			  SERVER_QUERY_NO_GOOD_INDEX_USED);
unknown's avatar
unknown committed
3900
  thd->tmp_table_used= 0;
unknown's avatar
unknown committed
3901 3902
  if (opt_bin_log)
    reset_dynamic(&thd->user_var_events);
3903
  thd->clear_error();
unknown's avatar
unknown committed
3904 3905 3906
  DBUG_VOID_RETURN;
}

3907

3908 3909 3910
void
mysql_init_select(LEX *lex)
{
unknown's avatar
unknown committed
3911
  SELECT_LEX *select_lex= lex->current_select;
unknown's avatar
unknown committed
3912
  select_lex->init_select();
3913
  select_lex->select_limit= HA_POS_ERROR;
3914 3915
  if (select_lex == &lex->select_lex)
  {
3916
    DBUG_ASSERT(lex->result == 0);
3917 3918 3919
    lex->exchange= 0;
    lex->proc_list.first= 0;
  }
3920 3921
}

3922

unknown's avatar
unknown committed
3923
bool
unknown's avatar
unknown committed
3924
mysql_new_select(LEX *lex, bool move_down)
3925
{
unknown's avatar
unknown committed
3926
  SELECT_LEX *select_lex = new(&lex->thd->mem_root) SELECT_LEX();
unknown's avatar
unknown committed
3927 3928
  if (!select_lex)
    return 1;
3929
  select_lex->select_number= ++lex->thd->select_number;
unknown's avatar
unknown committed
3930 3931 3932 3933 3934
  select_lex->init_query();
  select_lex->init_select();
  if (move_down)
  {
    /* first select_lex of subselect or derived table */
unknown's avatar
unknown committed
3935
    SELECT_LEX_UNIT *unit= new(&lex->thd->mem_root) SELECT_LEX_UNIT();
unknown's avatar
unknown committed
3936 3937 3938 3939
    if (!unit)
      return 1;
    unit->init_query();
    unit->init_select();
3940
    unit->thd= lex->thd;
unknown's avatar
unknown committed
3941
    unit->include_down(lex->current_select);
unknown's avatar
unknown committed
3942 3943
    unit->link_next= 0;
    unit->link_prev= 0;
3944
    unit->return_to= lex->current_select;
unknown's avatar
unknown committed
3945
    select_lex->include_down(unit);
3946
    // TODO: assign resolve_mode for fake subquery after merging with new tree
unknown's avatar
unknown committed
3947 3948
  }
  else
unknown's avatar
unknown committed
3949
  {
3950
    select_lex->include_neighbour(lex->current_select);
unknown's avatar
unknown committed
3951 3952 3953 3954 3955 3956 3957 3958
    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
3959
      fake= unit->fake_select_lex= new(&lex->thd->mem_root) SELECT_LEX();
unknown's avatar
unknown committed
3960 3961 3962 3963 3964
      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;
3965
      fake->select_limit= HA_POS_ERROR;
unknown's avatar
unknown committed
3966 3967
    }
  }
unknown's avatar
unknown committed
3968

3969
  select_lex->master_unit()->global_parameters= select_lex;
3970
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
3971
  lex->current_select= select_lex;
3972
  select_lex->resolve_mode= SELECT_LEX::SELECT_MODE;
unknown's avatar
unknown committed
3973
  return 0;
3974
}
unknown's avatar
unknown committed
3975

3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990
/*
  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)
{
3991
  THD *thd;
3992
  LEX *lex;
3993
  LEX_STRING tmp, null_lex_string;
3994
  DBUG_ENTER("create_select_for_variable");
3995 3996

  thd= current_thd;
3997
  lex= thd->lex;
3998 3999 4000 4001
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
4002 4003 4004
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
  add_item_to_list(thd, get_system_var(thd, OPT_SESSION, tmp,
				       null_lex_string));
4005 4006 4007
  DBUG_VOID_RETURN;
}

4008

unknown's avatar
unknown committed
4009 4010
void mysql_init_multi_delete(LEX *lex)
{
unknown's avatar
unknown committed
4011
  lex->sql_command=  SQLCOM_DELETE_MULTI;
unknown's avatar
unknown committed
4012
  mysql_init_select(lex);
4013
  lex->select_lex.select_limit= lex->unit.select_limit_cnt=
unknown's avatar
unknown committed
4014
    HA_POS_ERROR;
unknown's avatar
unknown committed
4015
  lex->select_lex.table_list.save_and_clear(&lex->auxilliary_table_list);
unknown's avatar
unknown committed
4016
}
unknown's avatar
unknown committed
4017

4018

4019 4020 4021 4022
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
unknown's avatar
unknown committed
4023

4024
void mysql_parse(THD *thd, char *inBuf, uint length)
unknown's avatar
unknown committed
4025 4026 4027
{
  DBUG_ENTER("mysql_parse");

unknown's avatar
unknown committed
4028
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
4029
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
unknown's avatar
unknown committed
4030
  {
unknown's avatar
unknown committed
4031
    LEX *lex= thd->lex;
4032
    if (!yyparse((void *)thd) && ! thd->is_fatal_error)
unknown's avatar
unknown committed
4033
    {
unknown's avatar
unknown committed
4034
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4035
      if (mqh_used && thd->user_connect &&
4036
	  check_mqh(thd, lex->sql_command))
4037 4038 4039 4040
      {
	thd->net.error = 0;
      }
      else
unknown's avatar
unknown committed
4041
#endif
4042
      {
unknown's avatar
unknown committed
4043 4044 4045 4046 4047
	if (thd->net.report_error)
	  send_error(thd, 0, NullS);
	else
	{
	  mysql_execute_command(thd);
unknown's avatar
SCRUM  
unknown committed
4048
	  query_cache_end_of_result(thd);
unknown's avatar
unknown committed
4049
	}
4050
      }
unknown's avatar
unknown committed
4051 4052
    }
    else
4053 4054
    {
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
4055
			 thd->is_fatal_error));
unknown's avatar
unknown committed
4056
      query_cache_abort(&thd->net);
4057
    }
unknown's avatar
unknown committed
4058
    thd->proc_info="freeing items";
4059
    thd->end_statement();
4060
    DBUG_ASSERT(thd->change_list.is_empty());
unknown's avatar
unknown committed
4061
  }
unknown's avatar
unknown committed
4062 4063 4064 4065
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
4066
#ifdef HAVE_REPLICATION
4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077
/*
  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
4078
  LEX *lex= thd->lex;
4079 4080
  bool error= 0;

unknown's avatar
unknown committed
4081
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
4082
  if (!yyparse((void*) thd) && ! thd->is_fatal_error &&
4083 4084
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
    error= 1;                /* Ignore question */
4085
  thd->end_statement();
4086 4087
  return error;
}
unknown's avatar
unknown committed
4088
#endif
unknown's avatar
unknown committed
4089 4090 4091 4092 4093 4094

/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

unknown's avatar
unknown committed
4095
bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
unknown's avatar
unknown committed
4096
		       char *length, char *decimals,
4097
		       uint type_modifier,
4098 4099
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
unknown's avatar
unknown committed
4100 4101
		       char *change, TYPELIB *interval, CHARSET_INFO *cs,
		       uint uint_geom_type)
unknown's avatar
unknown committed
4102 4103
{
  register create_field *new_field;
4104
  LEX  *lex= thd->lex;
unknown's avatar
unknown committed
4105
  uint allowed_type_modifier=0;
4106
  char warn_buff[MYSQL_ERRMSG_SIZE];
unknown's avatar
unknown committed
4107 4108 4109 4110
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
4111
    net_printf(thd, ER_TOO_LONG_IDENT, field_name); /* purecov: inspected */
unknown's avatar
unknown committed
4112 4113 4114 4115 4116
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
4117
    lex->key_list.push_back(new Key(Key::PRIMARY, NullS, HA_KEY_ALG_UNDEF,
4118
				    0, lex->col_list));
unknown's avatar
unknown committed
4119 4120 4121 4122 4123
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
4124
    lex->key_list.push_back(new Key(Key::UNIQUE, NullS, HA_KEY_ALG_UNDEF, 0,
unknown's avatar
unknown committed
4125 4126 4127 4128
				    lex->col_list));
    lex->col_list.empty();
  }

4129
  if (default_value)
unknown's avatar
unknown committed
4130
  {
4131
    /* 
unknown's avatar
unknown committed
4132 4133
      Default value should be literal => basic constants =>
      no need fix_fields()
4134 4135 4136
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
4137
    */
4138 4139 4140 4141 4142 4143 4144 4145
    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
4146
    {
4147
      default_value= 0;
4148 4149 4150
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
unknown's avatar
unknown committed
4151
	net_printf(thd,ER_INVALID_DEFAULT,field_name);
4152 4153 4154 4155 4156
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
unknown's avatar
unknown committed
4157
      net_printf(thd, ER_INVALID_DEFAULT, field_name);
unknown's avatar
unknown committed
4158 4159 4160
      DBUG_RETURN(1);
    }
  }
4161 4162 4163 4164 4165 4166 4167

  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
4168 4169 4170 4171
  if (!(new_field=new create_field()))
    DBUG_RETURN(1);
  new_field->field=0;
  new_field->field_name=field_name;
4172
  new_field->def= default_value;
unknown's avatar
unknown committed
4173 4174 4175 4176 4177 4178 4179 4180 4181 4182
  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;
4183
  new_field->charset=cs;
unknown's avatar
unknown committed
4184
  new_field->geom_type= (Field::geometry_type) uint_geom_type;
unknown's avatar
unknown committed
4185

4186 4187 4188 4189 4190 4191 4192 4193
  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
4194 4195
    new_field->comment.str=   (char*) comment->str;
    new_field->comment.length=comment->length;
4196
  }
4197 4198
  if (length && !(new_field->length= (uint) atoi(length)))
    length=0; /* purecov: inspected */
unknown's avatar
unknown committed
4199 4200 4201
  uint sign_len=type_modifier & UNSIGNED_FLAG ? 0 : 1;

  if (new_field->length && new_field->decimals &&
4202
      new_field->length < new_field->decimals+1 &&
unknown's avatar
unknown committed
4203
      new_field->decimals != NOT_FIXED_DEC)
4204
    new_field->length=new_field->decimals+1; /* purecov: inspected */
unknown's avatar
unknown committed
4205 4206 4207

  switch (type) {
  case FIELD_TYPE_TINY:
4208
    if (!length) new_field->length=MAX_TINYINT_WIDTH+sign_len;
unknown's avatar
unknown committed
4209 4210 4211
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_SHORT:
4212
    if (!length) new_field->length=MAX_SMALLINT_WIDTH+sign_len;
unknown's avatar
unknown committed
4213 4214 4215
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_INT24:
4216
    if (!length) new_field->length=MAX_MEDIUMINT_WIDTH+sign_len;
unknown's avatar
unknown committed
4217 4218 4219
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONG:
4220
    if (!length) new_field->length=MAX_INT_WIDTH+sign_len;
unknown's avatar
unknown committed
4221 4222 4223
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONGLONG:
4224
    if (!length) new_field->length=MAX_BIGINT_WIDTH;
unknown's avatar
unknown committed
4225 4226 4227 4228 4229 4230
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_NULL:
    break;
  case FIELD_TYPE_DECIMAL:
    if (!length)
unknown's avatar
unknown committed
4231 4232
    {
      if ((new_field->length= new_field->decimals))
4233 4234
        new_field->length++;
      else
unknown's avatar
unknown committed
4235 4236
        new_field->length= 10;                  // Default length for DECIMAL
    }
4237 4238 4239 4240 4241 4242
    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
4243
    break;
4244 4245
  case FIELD_TYPE_STRING:
  case FIELD_TYPE_VAR_STRING:
4246
    if (new_field->length <= MAX_FIELD_CHARLENGTH || default_value)
4247 4248 4249 4250
      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
4251
	    (cs == &my_charset_bin) ? "BLOB" : "TEXT");
4252 4253 4254
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_AUTO_CONVERT,
		 warn_buff);
    /* fall through */
unknown's avatar
unknown committed
4255 4256 4257 4258
  case FIELD_TYPE_BLOB:
  case FIELD_TYPE_TINY_BLOB:
  case FIELD_TYPE_LONG_BLOB:
  case FIELD_TYPE_MEDIUM_BLOB:
unknown's avatar
unknown committed
4259
  case FIELD_TYPE_GEOMETRY:
4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273
    if (new_field->length)
    {
      /* The user has given a length to the blob column */
      if (new_field->length < 256)
	type= FIELD_TYPE_TINY_BLOB;
      if (new_field->length < 65536)
	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
4274 4275 4276 4277 4278 4279
    if (default_value)				// Allow empty as default value
    {
      String str,*res;
      res=default_value->val_str(&str);
      if (res->length())
      {
4280
	net_printf(thd,ER_BLOB_CANT_HAVE_DEFAULT,field_name); /* purecov: inspected */
unknown's avatar
unknown committed
4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299
	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)
      {
4300
	net_printf(thd,ER_WRONG_FIELD_SPEC,field_name);
unknown's avatar
unknown committed
4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329
	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
4330
    else if (new_field->length != 19)
unknown's avatar
unknown committed
4331
    {
4332 4333 4334 4335
      /*
        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
4336 4337 4338
      new_field->length=((new_field->length+1)/2)*2; /* purecov: inspected */
      new_field->length= min(new_field->length,14); /* purecov: inspected */
    }
4339
    new_field->flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359
    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
    {
4360 4361 4362 4363 4364 4365 4366 4367
      /*
        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
4368
        information about all TIMESTAMP fields in table will be availiable.
4369 4370 4371

        If we have TIMESTAMP NULL column without explicit DEFAULT value
        we treat it as having DEFAULT NULL attribute.
4372
      */
4373 4374 4375 4376 4377
      new_field->unireg_check= on_update_value ?
                               Field::TIMESTAMP_UN_FIELD :
                               (new_field->flags & NOT_NULL_FLAG ?
                                Field::TIMESTAMP_OLD_FIELD:
                                Field::NONE);
4378
    }
unknown's avatar
unknown committed
4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396
    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:
    {
      if (interval->count > sizeof(longlong)*8)
      {
4397
	net_printf(thd,ER_TOO_BIG_SET,field_name); /* purecov: inspected */
unknown's avatar
unknown committed
4398 4399 4400 4401 4402 4403 4404 4405
	DBUG_RETURN(1);				/* purecov: inspected */
      }
      new_field->pack_length=(interval->count+7)/8;
      if (new_field->pack_length > 4)
	new_field->pack_length=8;
      new_field->interval=interval;
      new_field->length=0;
      for (const char **pos=interval->type_names; *pos ; pos++)
unknown's avatar
unknown committed
4406
      {
unknown's avatar
unknown committed
4407 4408 4409 4410
        uint length= (uint) strip_sp((char*) *pos)+1;
        CHARSET_INFO *cs= thd->variables.character_set_client;
        length= cs->cset->numchars(cs, *pos, *pos+length);
        new_field->length+= length;
unknown's avatar
unknown committed
4411
      }
unknown's avatar
unknown committed
4412 4413 4414 4415
      new_field->length--;
      set_if_smaller(new_field->length,MAX_FIELD_WIDTH-1);
      if (default_value)
      {
4416 4417
	char *not_used;
	uint not_used2;
4418
	bool not_used3;
4419

unknown's avatar
unknown committed
4420 4421 4422
	thd->cuted_fields=0;
	String str,*res;
	res=default_value->val_str(&str);
4423
	(void) find_set(interval, res->ptr(), res->length(), &not_used,
4424
			&not_used2, &not_used3);
unknown's avatar
unknown committed
4425 4426
	if (thd->cuted_fields)
	{
4427
	  net_printf(thd,ER_INVALID_DEFAULT,field_name);
unknown's avatar
unknown committed
4428 4429 4430 4431 4432 4433 4434 4435 4436
	  DBUG_RETURN(1);
	}
      }
    }
    break;
  case FIELD_TYPE_ENUM:
    {
      new_field->interval=interval;
      new_field->pack_length=interval->count < 256 ? 1 : 2; // Should be safe
unknown's avatar
unknown committed
4437
      new_field->length=(uint) strip_sp((char*) interval->type_names[0]);
unknown's avatar
unknown committed
4438 4439
      for (const char **pos=interval->type_names+1; *pos ; pos++)
      {
unknown's avatar
unknown committed
4440 4441 4442 4443
        uint length=(uint) strip_sp((char*) *pos);
        CHARSET_INFO *cs= thd->variables.character_set_client;
        length= cs->cset->numchars(cs, *pos, *pos+length);
        set_if_bigger(new_field->length,length);
unknown's avatar
unknown committed
4444 4445 4446 4447 4448 4449
      }
      set_if_smaller(new_field->length,MAX_FIELD_WIDTH-1);
      if (default_value)
      {
	String str,*res;
	res=default_value->val_str(&str);
4450 4451
	res->strip_sp();
	if (!find_type(interval, res->ptr(), res->length(), 0))
unknown's avatar
unknown committed
4452
	{
4453
	  net_printf(thd,ER_INVALID_DEFAULT,field_name);
unknown's avatar
unknown committed
4454 4455 4456 4457 4458 4459 4460
	  DBUG_RETURN(1);
	}
      }
      break;
    }
  }

4461 4462
  if ((new_field->length > MAX_FIELD_CHARLENGTH && type != FIELD_TYPE_SET && 
       type != FIELD_TYPE_ENUM) ||
unknown's avatar
unknown committed
4463
      (!new_field->length && !(new_field->flags & BLOB_FLAG) &&
4464
       type != FIELD_TYPE_STRING &&
unknown's avatar
SCRUM  
unknown committed
4465
       type != FIELD_TYPE_VAR_STRING && type != FIELD_TYPE_GEOMETRY))
unknown's avatar
unknown committed
4466
  {
4467
    net_printf(thd,ER_TOO_BIG_FIELDLENGTH,field_name,
4468
	       MAX_FIELD_CHARLENGTH);		/* purecov: inspected */
unknown's avatar
unknown committed
4469 4470 4471 4472 4473
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  type_modifier&= AUTO_INCREMENT_FLAG;
  if ((~allowed_type_modifier) & type_modifier)
  {
4474
    net_printf(thd,ER_WRONG_FIELD_SPEC,field_name);
unknown's avatar
unknown committed
4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495
    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
4496
add_proc_to_list(THD* thd, Item *item)
unknown's avatar
unknown committed
4497 4498 4499 4500
{
  ORDER *order;
  Item	**item_ptr;

unknown's avatar
unknown committed
4501
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
unknown's avatar
unknown committed
4502 4503 4504 4505 4506
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
4507
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
4508 4509 4510 4511 4512 4513 4514 4515
  return 0;
}


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

static void remove_escape(char *name)
{
4516 4517
  if (!*name)					// For empty DB names
    return;
unknown's avatar
unknown committed
4518 4519
  char *to;
#ifdef USE_MB
unknown's avatar
unknown committed
4520
  char *strend=name+(uint) strlen(name);
unknown's avatar
unknown committed
4521 4522 4523 4524 4525 4526
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
/*    if ((l = ismbchar(name, name+MBMAXLEN))) { Wei He: I think it's wrong */
4527 4528
    if (use_mb(system_charset_info) &&
        (l = my_ismbchar(system_charset_info, name, strend)))
unknown's avatar
unknown committed
4529 4530 4531 4532 4533 4534 4535 4536
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
unknown's avatar
unknown committed
4537
      name++;					// Skip '\\'
unknown's avatar
unknown committed
4538 4539 4540 4541 4542 4543 4544 4545 4546 4547
    *to++= *name;
  }
  *to=0;
}

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


unknown's avatar
unknown committed
4548
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
unknown's avatar
unknown committed
4549 4550 4551
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
unknown's avatar
unknown committed
4552
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
unknown's avatar
unknown committed
4553
    DBUG_RETURN(1);
unknown's avatar
unknown committed
4554 4555
  order->item_ptr= item;
  order->item= &order->item_ptr;
unknown's avatar
unknown committed
4556 4557 4558
  order->asc = asc;
  order->free_me=0;
  order->used=0;
unknown's avatar
unknown committed
4559
  list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
4560 4561 4562 4563
  DBUG_RETURN(0);
}


unknown's avatar
unknown committed
4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582
/*
  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
4583 4584
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
4585
					     LEX_STRING *alias,
unknown's avatar
unknown committed
4586 4587
					     ulong table_options,
					     thr_lock_type lock_type,
4588 4589
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
unknown's avatar
unknown committed
4590
                                             LEX_STRING *option)
unknown's avatar
unknown committed
4591 4592 4593 4594 4595 4596 4597 4598
{
  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
4599
  if (check_table_name(table->table.str,table->table.length) ||
4600
      table->db.str && check_db_name(table->db.str))
unknown's avatar
unknown committed
4601
  {
4602
    net_printf(thd, ER_WRONG_TABLE_NAME, table->table.str);
unknown's avatar
unknown committed
4603 4604 4605 4606
    DBUG_RETURN(0);
  }

  if (!alias)					/* Alias is case sensitive */
4607 4608 4609 4610 4611 4612
  {
    if (table->sel)
    {
      net_printf(thd,ER_DERIVED_MUST_HAVE_ALIAS);
      DBUG_RETURN(0);
    }
4613
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
unknown's avatar
unknown committed
4614
      DBUG_RETURN(0);
4615
  }
unknown's avatar
unknown committed
4616
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
4617
    DBUG_RETURN(0);				/* purecov: inspected */
unknown's avatar
unknown committed
4618
  if (table->db.str)
4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629
  {
    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
  {
4630 4631
    /* The following can't be "" as we may do 'casedn_str()' on it */
    ptr->db= empty_c_string;
4632 4633
    ptr->db_length= 0;
  }
unknown's avatar
unknown committed
4634

4635
  ptr->alias= alias_str;
4636 4637
  if (lower_case_table_names && table->table.length)
    my_casedn_str(files_charset_info, table->table.str);
unknown's avatar
unknown committed
4638
  ptr->real_name=table->table.str;
4639
  ptr->real_name_length=table->table.length;
4640
  ptr->lock_type=   lock_type;
unknown's avatar
unknown committed
4641 4642
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
unknown's avatar
unknown committed
4643
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
4644
  ptr->derived=	    table->sel;
unknown's avatar
unknown committed
4645
  ptr->cacheable_table= 1;
4646 4647 4648 4649 4650 4651
  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
4652
  ptr->option= option ? option->str : 0;
unknown's avatar
unknown committed
4653
  /* check that used name is unique */
4654
  if (lock_type != TL_IGNORE)
unknown's avatar
unknown committed
4655
  {
4656
    for (TABLE_LIST *tables=(TABLE_LIST*) table_list.first ;
unknown's avatar
unknown committed
4657
	 tables ;
unknown's avatar
unknown committed
4658
	 tables=tables->next)
unknown's avatar
unknown committed
4659
    {
4660 4661
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
unknown's avatar
unknown committed
4662
      {
4663
	net_printf(thd,ER_NONUNIQ_TABLE,alias_str); /* purecov: tested */
unknown's avatar
unknown committed
4664 4665
	DBUG_RETURN(0);				/* purecov: tested */
      }
unknown's avatar
unknown committed
4666 4667
    }
  }
unknown's avatar
unknown committed
4668
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next);
unknown's avatar
unknown committed
4669 4670 4671
  DBUG_RETURN(ptr);
}

unknown's avatar
unknown committed
4672

unknown's avatar
unknown committed
4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685
/*
  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
4686
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
unknown's avatar
unknown committed
4687 4688 4689 4690 4691 4692
{
  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
4693
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first ;
unknown's avatar
unknown committed
4694 4695 4696 4697 4698 4699 4700 4701 4702
       tables ;
       tables=tables->next)
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
4703

unknown's avatar
unknown committed
4704 4705
void add_join_on(TABLE_LIST *b,Item *expr)
{
4706
  if (expr)
4707
  {
4708 4709 4710 4711 4712 4713 4714 4715
    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();
4716
  }
unknown's avatar
unknown committed
4717 4718 4719
}


4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737
/*
  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
4738 4739 4740 4741 4742
void add_join_natural(TABLE_LIST *a,TABLE_LIST *b)
{
  b->natural_join=a;
}

4743
/*
4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760
  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
4761 4762
*/

4763 4764
bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
                          bool *write_to_binlog)
unknown's avatar
unknown committed
4765 4766 4767
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
4768
  bool tmp_write_to_binlog= 1;
unknown's avatar
SCRUM  
unknown committed
4769
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
4770 4771
  if (options & REFRESH_GRANT)
  {
4772
    acl_reload(thd);
unknown's avatar
unknown committed
4773
    grant_reload(thd);
4774
    if (mqh_used)
unknown's avatar
unknown committed
4775
      reset_mqh(thd,(LEX_USER *) NULL,TRUE);
unknown's avatar
unknown committed
4776
  }
unknown's avatar
SCRUM  
unknown committed
4777
#endif
unknown's avatar
unknown committed
4778 4779
  if (options & REFRESH_LOG)
  {
4780
    /*
unknown's avatar
unknown committed
4781 4782
      Flush the normal query log, the update log, the binary log,
      the slow query log, and the relay log (if it exists).
4783
    */
unknown's avatar
unknown committed
4784

4785 4786 4787 4788 4789 4790
    /* 
     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)
    */
    tmp_write_to_binlog= 0;
unknown's avatar
unknown committed
4791 4792 4793 4794
    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
4795
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
4796
    if (mysql_bin_log.is_open() && expire_logs_days)
4797 4798 4799
    {
      long purge_time= time(0) - expire_logs_days*24*60*60;
      if (purge_time >= 0)
4800
	mysql_bin_log.purge_logs_before_date(purge_time);
4801
    }
4802
    pthread_mutex_lock(&LOCK_active_mi);
4803
    rotate_relay_log(active_mi);
4804
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
4805
#endif
unknown's avatar
unknown committed
4806 4807
    if (ha_flush_logs())
      result=1;
unknown's avatar
unknown committed
4808 4809
    if (flush_error_log())
      result=1;
unknown's avatar
unknown committed
4810
  }
unknown's avatar
unknown committed
4811
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
4812 4813
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
unknown's avatar
unknown committed
4814
    query_cache.pack();				// FLUSH QUERY CACHE
unknown's avatar
unknown committed
4815 4816 4817 4818
    options &= ~REFRESH_QUERY_CACHE; //don't flush all cache, just free memory
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
unknown's avatar
unknown committed
4819
    query_cache.flush();			// RESET QUERY CACHE
unknown's avatar
unknown committed
4820
  }
unknown's avatar
unknown committed
4821
#endif /*HAVE_QUERY_CACHE*/
4822 4823 4824 4825 4826
  /*
    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
4827
  {
4828
    if ((options & REFRESH_READ_LOCK) && thd)
unknown's avatar
unknown committed
4829
    {
unknown's avatar
unknown committed
4830 4831 4832 4833
      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
4834
      tmp_write_to_binlog= 0;
4835 4836
      if (lock_global_read_lock(thd))
	return 1;
4837 4838 4839
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                 tables);
      make_global_read_lock_block_commit(thd);
unknown's avatar
unknown committed
4840
    }
4841 4842
    else
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
unknown's avatar
unknown committed
4843
    my_dbopt_cleanup();
unknown's avatar
unknown committed
4844 4845 4846 4847 4848 4849 4850
  }
  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
4851
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
4852
  if (options & REFRESH_MASTER)
4853 4854
  {
    tmp_write_to_binlog= 0;
4855 4856
    if (reset_master(thd))
      result=1;
4857
  }
4858
#endif
unknown's avatar
unknown committed
4859
#ifdef OPENSSL
4860 4861 4862 4863 4864 4865
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
unknown's avatar
unknown committed
4866
#ifdef HAVE_REPLICATION
4867 4868
 if (options & REFRESH_SLAVE)
 {
4869
   tmp_write_to_binlog= 0;
4870
   pthread_mutex_lock(&LOCK_active_mi);
4871
   if (reset_slave(thd, active_mi))
4872
     result=1;
4873
   pthread_mutex_unlock(&LOCK_active_mi);
4874
 }
4875
#endif
4876
 if (options & REFRESH_USER_RESOURCES)
4877
   reset_mqh(thd,(LEX_USER *) NULL);
4878 4879
 if (write_to_binlog)
   *write_to_binlog= tmp_write_to_binlog;
4880
 return result;
unknown's avatar
unknown committed
4881 4882
}

4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894
/*
  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
*/

4895
void kill_one_thread(THD *thd, ulong id)
unknown's avatar
unknown committed
4896 4897 4898
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
4899 4900
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  I_List_iterator<THD> it(threads);
unknown's avatar
unknown committed
4901 4902 4903 4904
  while ((tmp=it++))
  {
    if (tmp->thread_id == id)
    {
4905 4906
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
unknown's avatar
unknown committed
4907 4908 4909
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922
  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
4923
  if (!error)
4924
    send_ok(thd);
unknown's avatar
unknown committed
4925
  else
4926
    net_printf(thd,error,id);
unknown's avatar
unknown committed
4927 4928 4929 4930 4931 4932 4933 4934 4935 4936
}

/* 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)
4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948
      *(ulong*) ptr->value= 0;
    else if (ptr->type == SHOW_KEY_CACHE_LONG)
    {
      /*
	Reset value in 'default' key cache.
	This needs to be recoded when we have thread specific key values
      */
      char *value= (((char*) sql_key_cache) +
		    (uint) ((char*) (ptr->value) -
			    (char*) &dflt_key_cache_var));
      *(ulong*) value= 0;
    }
unknown's avatar
unknown committed
4949 4950 4951
  }
  pthread_mutex_unlock(&LOCK_status);
}
4952 4953 4954 4955


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

unknown's avatar
unknown committed
4956 4957
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name)
4958
{
4959
  char buff[FN_REFLEN],*ptr, *end;
4960 4961 4962 4963 4964 4965 4966
  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))
  {
4967
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
4968 4969 4970 4971
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
4972
  end=convert_dirname(buff, *filename_ptr, NullS);
unknown's avatar
unknown committed
4973
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
4974 4975
    return 1;					// End of memory
  *filename_ptr=ptr;
4976
  strxmov(ptr,buff,table_name,NullS);
4977 4978
  return 0;
}
4979

4980

4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994
/*
  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;
4995
  if (thd->lex->current_select != &thd->lex->select_lex)
4996 4997
  {
    char command[80];
4998 4999
    strmake(command, thd->lex->yylval->symbol.str,
	    min(thd->lex->yylval->symbol.length, sizeof(command)-1));
5000
    net_printf(thd, ER_CANT_USE_OPTION_HERE, command);
5001 5002 5003 5004
    return 1;
  }
  return 0;
}
unknown's avatar
unknown committed
5005

unknown's avatar
unknown committed
5006

unknown's avatar
unknown committed
5007
Comp_creator *comp_eq_creator(bool invert)
unknown's avatar
unknown committed
5008
{
unknown's avatar
unknown committed
5009
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
unknown's avatar
unknown committed
5010 5011
}

unknown's avatar
unknown committed
5012

unknown's avatar
unknown committed
5013
Comp_creator *comp_ge_creator(bool invert)
unknown's avatar
unknown committed
5014
{
unknown's avatar
unknown committed
5015
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
unknown's avatar
unknown committed
5016 5017
}

unknown's avatar
unknown committed
5018

unknown's avatar
unknown committed
5019
Comp_creator *comp_gt_creator(bool invert)
unknown's avatar
unknown committed
5020
{
unknown's avatar
unknown committed
5021
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
unknown's avatar
unknown committed
5022 5023
}

unknown's avatar
unknown committed
5024

unknown's avatar
unknown committed
5025
Comp_creator *comp_le_creator(bool invert)
unknown's avatar
unknown committed
5026
{
unknown's avatar
unknown committed
5027
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
unknown's avatar
unknown committed
5028 5029
}

unknown's avatar
unknown committed
5030

unknown's avatar
unknown committed
5031
Comp_creator *comp_lt_creator(bool invert)
unknown's avatar
unknown committed
5032
{
unknown's avatar
unknown committed
5033
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
unknown's avatar
unknown committed
5034 5035
}

unknown's avatar
unknown committed
5036

unknown's avatar
unknown committed
5037
Comp_creator *comp_ne_creator(bool invert)
unknown's avatar
unknown committed
5038
{
unknown's avatar
unknown committed
5039
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
unknown's avatar
unknown committed
5040
}
unknown's avatar
unknown committed
5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060


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

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

  Item_allany_subselect *it=
5068
    new Item_allany_subselect(left_expr, (*cmp)(all), select_lex, all);
unknown's avatar
unknown committed
5069 5070 5071 5072 5073
  if (all)
    return it->upper_not= new Item_func_not_all(it);	/* ALL */

  return it;						/* ANY/SOME */
}
5074 5075


5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090
/*
  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;
5091 5092 5093
  ALTER_INFO alter_info;
  alter_info.flags= ALTER_ADD_INDEX;
  alter_info.is_simple= 0;
5094 5095 5096 5097 5098 5099 5100
  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,
5101 5102
				fields, keys, 0, (ORDER*)0,
				DUP_ERROR, &alter_info));
5103 5104 5105
}


5106
int mysql_drop_index(THD *thd, TABLE_LIST *table_list, ALTER_INFO *alter_info)
5107 5108 5109 5110 5111 5112 5113 5114
{
  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;
5115 5116 5117
  alter_info->clear();
  alter_info->flags= ALTER_DROP_INDEX;
  alter_info->is_simple= 0;
5118 5119
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->real_name,
				&create_info, table_list,
5120 5121
				fields, keys, 0, (ORDER*)0,
				DUP_ERROR, alter_info));
5122
}
unknown's avatar
merge  
unknown committed
5123 5124


5125 5126 5127 5128 5129
/*
  Multi update query pre-check

  SYNOPSIS
    multi_update_precheck()
unknown's avatar
unknown committed
5130 5131
    thd		Thread handler
    tables	Global table list
5132

unknown's avatar
unknown committed
5133
  RETURN VALUE
unknown's avatar
unknown committed
5134 5135 5136
    0   OK
    1   Error (message is sent to user)
    -1  Error (message is not sent to user)
5137
*/
unknown's avatar
unknown committed
5138

5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160
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)
  {
    if ((check_access(thd, UPDATE_ACL, table->db,
		      &table->grant.privilege, 0, 1) ||
unknown's avatar
unknown committed
5161
	 grant_option && check_grant(thd, UPDATE_ACL, table, 0, 1, 1)) &&
5162 5163
	(check_access(thd, SELECT_ACL, table->db,
		      &table->grant.privilege, 0, 0) ||
unknown's avatar
unknown committed
5164
	 grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
5165
      DBUG_RETURN(1);
unknown's avatar
unknown committed
5166 5167 5168 5169 5170

    /*
      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
    */
5171
    if (table->table_list)
unknown's avatar
unknown committed
5172
      table->table_list->table_in_update_from_clause= 1;
5173
  }
unknown's avatar
unknown committed
5174 5175 5176
  /*
    Is there tables of subqueries?
  */
5177 5178 5179 5180
  if (&lex->select_lex != lex->all_selects_list)
  {
    for (table= tables; table; table= table->next)
    {
unknown's avatar
unknown committed
5181
      if (table->table_in_update_from_clause)
5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194
      {
	/*
	  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;
      }
      else
      {
	if (check_access(thd, SELECT_ACL, table->db,
			 &table->grant.privilege, 0, 0) ||
unknown's avatar
unknown committed
5195
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218
	  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
5219 5220 5221
    thd			Thread handler
    tables		Global table list
    table_count		Pointer to table counter
5222

unknown's avatar
unknown committed
5223
  RETURN VALUE
unknown's avatar
unknown committed
5224 5225 5226
    0   OK
    1   error (message is sent to user)
    -1  error (message is not sent to user)
5227 5228 5229 5230 5231 5232 5233 5234
*/
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
5235 5236 5237
  TABLE_LIST *target_tbl;

  *table_count= 0;
5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249

  /* 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
5250
  for (target_tbl= aux_tables; target_tbl; target_tbl= target_tbl->next)
5251 5252 5253 5254 5255 5256
  {
    (*table_count)++;
    /* All tables in aux_tables must be found in FROM PART */
    TABLE_LIST *walk;
    for (walk= delete_tables; walk; walk= walk->next)
    {
unknown's avatar
unknown committed
5257 5258 5259
      if (!my_strcasecmp(table_alias_charset,
			 target_tbl->alias, walk->alias) &&
	  !strcmp(walk->db, target_tbl->db))
5260 5261 5262 5263
	break;
    }
    if (!walk)
    {
unknown's avatar
unknown committed
5264 5265
      my_error(ER_UNKNOWN_TABLE, MYF(0), target_tbl->real_name,
	       "MULTI DELETE");
5266 5267 5268 5269
      DBUG_RETURN(-1);
    }
    if (walk->derived)
    {
unknown's avatar
unknown committed
5270 5271
      my_error(ER_NON_UPDATABLE_TABLE, MYF(0), target_tbl->real_name,
	       "DELETE");
5272 5273
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
5274 5275
    walk->lock_type= target_tbl->lock_type;
    target_tbl->table_list= walk;	// Remember corresponding table
5276 5277 5278 5279 5280 5281 5282 5283 5284 5285
  }
  DBUG_RETURN(0);
}


/*
  INSERT ... SELECT query pre-check

  SYNOPSIS
    multi_delete_precheck()
unknown's avatar
unknown committed
5286 5287
    thd		Thread handler
    tables	Global table list
5288

unknown's avatar
unknown committed
5289
  RETURN VALUE
unknown's avatar
unknown committed
5290 5291 5292
    0   OK
    1   Error (message is sent to user)
    -1  Error (message is not sent to user)
5293
*/
unknown's avatar
unknown committed
5294

5295 5296 5297 5298 5299 5300 5301 5302 5303
int insert_select_precheck(THD *thd, TABLE_LIST *tables)
{
  DBUG_ENTER("insert_select_precheck");
  /*
    Check that we have modify privileges for the first table and
    select privileges for the rest
  */
  ulong privilege= (thd->lex->duplicates == DUP_REPLACE ?
		    INSERT_ACL | DELETE_ACL : INSERT_ACL);
unknown's avatar
unknown committed
5304 5305 5306 5307 5308 5309 5310 5311 5312
  DBUG_RETURN(check_one_table_access(thd, privilege, tables) ? 1 : 0);
}


/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
unknown's avatar
unknown committed
5313 5314
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
5315 5316

  RETURN VALUE
unknown's avatar
unknown committed
5317 5318 5319
    0   OK
    1   Error (message is sent to user)
    -1  Error (message is not sent to user)
unknown's avatar
unknown committed
5320
*/
unknown's avatar
unknown committed
5321

unknown's avatar
unknown committed
5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339
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
5340 5341
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
5342 5343

  RETURN VALUE
unknown's avatar
unknown committed
5344 5345 5346
    0   OK
    1   error (message is sent to user)
    -1  error (message is not sent to user)
unknown's avatar
unknown committed
5347
*/
unknown's avatar
unknown committed
5348

unknown's avatar
unknown committed
5349 5350 5351 5352 5353
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
5354
  /* Set privilege for the WHERE clause */
unknown's avatar
unknown committed
5355 5356 5357 5358 5359 5360 5361 5362 5363 5364
  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
5365 5366
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
5367 5368

  RETURN VALUE
unknown's avatar
unknown committed
5369 5370 5371
    0   OK
    1   error (message is sent to user)
    -1  error (message is not sent to user)
unknown's avatar
unknown committed
5372
*/
unknown's avatar
unknown committed
5373

5374
int insert_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
5375 5376 5377 5378
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

5379 5380 5381
  ulong privilege= INSERT_ACL |
                   (lex->duplicates == DUP_REPLACE ? DELETE_ACL : 0) |
                   (lex->duplicates == DUP_UPDATE ? UPDATE_ACL : 0);
unknown's avatar
unknown committed
5382 5383

  if (check_one_table_access(thd, privilege, tables))
5384
    DBUG_RETURN(1);
unknown's avatar
unknown committed
5385 5386 5387 5388 5389 5390

  if (lex->select_lex.item_list.elements != lex->value_list.elements)
  {
    my_error(ER_WRONG_VALUE_COUNT, MYF(0));
    DBUG_RETURN(-1);
  }
5391 5392
  DBUG_RETURN(0);
}
unknown's avatar
unknown committed
5393 5394 5395 5396 5397 5398 5399


/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
unknown's avatar
unknown committed
5400 5401 5402
    thd			Thread handler
    tables		Global table list
    create_table	Table which will be created
unknown's avatar
unknown committed
5403 5404

  RETURN VALUE
unknown's avatar
unknown committed
5405 5406 5407
    0   OK
    1   Error (message is sent to user)
    -1  Error (message is not sent to user)
unknown's avatar
unknown committed
5408
*/
unknown's avatar
unknown committed
5409

unknown's avatar
unknown committed
5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425
int create_table_precheck(THD *thd, TABLE_LIST *tables,
			  TABLE_LIST *create_table)
{
  LEX *lex= thd->lex;
  DBUG_ENTER("create_table_precheck");
  ulong want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
		    CREATE_TMP_ACL : CREATE_ACL);
  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))
    DBUG_RETURN(1);
  DBUG_RETURN((grant_option && want_priv != CREATE_TMP_ACL &&
	       check_grant(thd, want_priv, create_table, 0, UINT_MAX, 0)) ?
5426
	      1 : 0);
unknown's avatar
unknown committed
5427
}
unknown's avatar
unknown committed
5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463


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