sql_parse.cc 107 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
#include <m_ctype.h>
#include <myisam.h>
#include <my_dir.h>
unknown's avatar
unknown committed
24
#include <assert.h>
unknown's avatar
unknown committed
25

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

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

49 50 51 52
#define MEM_ROOT_BLOCK_SIZE       8192
#define MEM_ROOT_PREALLOC         8192
#define TRANS_MEM_ROOT_BLOCK_SIZE 4096
#define TRANS_MEM_ROOT_PREALLOC   4096
unknown's avatar
unknown committed
53

unknown's avatar
unknown committed
54 55
extern int yyparse(void);
extern "C" pthread_mutex_t THR_LOCK_keycache;
56 57 58
#ifdef SOLARIS
extern "C" int gethostname(char *name, int namelen);
#endif
unknown's avatar
unknown committed
59

60 61
static int check_for_max_user_connections(USER_CONN *uc);
static void decrease_user_connections(USER_CONN *uc);
unknown's avatar
unknown committed
62
static bool check_db_used(THD *thd,TABLE_LIST *tables);
63
static bool check_merge_table_access(THD *thd, char *db, TABLE_LIST *tables);
unknown's avatar
unknown committed
64
static bool check_dup(const char *db, const char *name, TABLE_LIST *tables);
unknown's avatar
unknown committed
65 66 67
static void mysql_init_query(THD *thd);
static void remove_escape(char *name);
static void refresh_status(void);
unknown's avatar
unknown committed
68 69
static bool append_file_to_dir(THD *thd, char **filename_ptr,
			       char *table_name);
unknown's avatar
unknown committed
70
static bool create_total_list(THD *thd, LEX *lex, TABLE_LIST **result);
unknown's avatar
unknown committed
71

72
const char *any_db="*any*";	// Special symbol for check_access
unknown's avatar
unknown committed
73 74 75 76 77

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",
78 79
  "Binlog Dump","Table Dump",  "Connect Out", "Register Slave",
  "Error"					// Last command number
unknown's avatar
unknown committed
80 81 82 83 84 85 86
};

bool volatile abort_slave = 0;

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

unknown's avatar
unknown committed
103 104 105 106 107 108 109 110 111 112 113
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
  }
}

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


128 129 130
static HASH hash_user_connections;
extern  pthread_mutex_t LOCK_user_conn;

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

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

143 144 145
  user_len=strlen(user);
  host_len=strlen(host);
  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 156 157
      send_error(&current_thd->net, 0, NullS);	// Out of memory
      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;
167
    if (max_user_connections && mqh->connections > max_user_connections) 
168
      uc->user_resources.connections = max_user_connections;
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
    uc->intime=thd->thr_create_time;
    if (hash_insert(&hash_user_connections, (byte*) uc))
    {
      my_free((char*) uc,0);
      send_error(&current_thd->net, 0, NullS);	// Out of memory
      return_val=1;
      goto end;
    }
  }
  thd->user_connect=uc;
end:
  (void) pthread_mutex_unlock(&LOCK_user_conn);
  return return_val;
 
}
184 185 186


/*
unknown's avatar
unknown committed
187 188
  Check if user is ok
  Updates:
189
  thd->{user,master_access,priv_user,priv_host,db,db_access}
unknown's avatar
unknown committed
190 191 192 193 194 195 196
*/

static bool check_user(THD *thd,enum_server_command command, const char *user,
		       const char *passwd, const char *db, bool check_count)
{
  NET *net= &thd->net;
  thd->db=0;
unknown's avatar
unknown committed
197
  thd->db_length=0;
198
  USER_RESOURCES ur;
unknown's avatar
unknown committed
199
  char tmp_passwd[SCRAMBLE_LENGTH + 1];
unknown's avatar
unknown committed
200

201 202
  if (passwd[0] && strlen(passwd) != SCRAMBLE_LENGTH)
    return 1;
203 204 205 206 207 208 209
  /*
    Move password to temporary buffer as it may be stored in communication
    buffer
  */
  strmov(tmp_passwd, passwd);
  passwd= tmp_passwd;				// Use local copy

unknown's avatar
unknown committed
210 211 212 213 214
  if (!(thd->user = my_strdup(user, MYF(0))))
  {
    send_error(net,ER_OUT_OF_RESOURCES);
    return 1;
  }
215
  thd->master_access=acl_getroot(thd, thd->host, thd->ip, thd->user,
216
				 passwd, thd->scramble,
217
                                 &thd->priv_user, thd->priv_host,
unknown's avatar
unknown committed
218 219
				 protocol_version == 9 ||
				 !(thd->client_capabilities &
220
				   CLIENT_LONG_PASSWORD),&ur);
unknown's avatar
unknown committed
221
  DBUG_PRINT("info",
222
	     ("Capabilities: %d  packet_length: %ld  Host: '%s'  Login user: '%s'  Priv_user: '%s'  Using password: %s  Access: %u  db: '%s'",
unknown's avatar
unknown committed
223
	      thd->client_capabilities, thd->max_client_packet_length,
224
	      thd->host_or_ip, thd->user, thd->priv_user,
unknown's avatar
unknown committed
225 226 227 228 229 230
	      passwd[0] ? "yes": "no",
	      thd->master_access, thd->db ? thd->db : "*none*"));
  if (thd->master_access & NO_ACCESS)
  {
    net_printf(net, ER_ACCESS_DENIED_ERROR,
	       thd->user,
231
	       thd->host_or_ip,
unknown's avatar
unknown committed
232
	       passwd[0] ? ER(ER_YES) : ER(ER_NO));
233
    mysql_log.write(thd,COM_CONNECT,ER(ER_ACCESS_DENIED_ERROR),
unknown's avatar
unknown committed
234
		    thd->user,
235
		    thd->host_or_ip,
unknown's avatar
unknown committed
236 237 238 239 240 241 242
		    passwd[0] ? ER(ER_YES) : ER(ER_NO));
    return(1);					// Error already given
  }
  if (check_count)
  {
    VOID(pthread_mutex_lock(&LOCK_thread_count));
    bool tmp=(thread_count - delayed_insert_threads >= max_connections &&
unknown's avatar
unknown committed
243
	      !(thd->master_access & SUPER_ACL));
unknown's avatar
unknown committed
244 245 246 247 248 249 250
    VOID(pthread_mutex_unlock(&LOCK_thread_count));
    if (tmp)
    {						// Too many connections
      send_error(net, ER_CON_COUNT_ERROR);
      return(1);
    }
  }
251
  mysql_log.write(thd,command,
unknown's avatar
unknown committed
252 253 254 255
		  (thd->priv_user == thd->user ?
		   (char*) "%s@%s on %s" :
		   (char*) "%s@%s as anonymous on %s"),
		  user,
256
		  thd->host_or_ip,
unknown's avatar
unknown committed
257 258
		  db ? db : (char*) "");
  thd->db_access=0;
unknown's avatar
unknown committed
259
  /* Don't allow user to connect if he has done too many queries */
unknown's avatar
unknown committed
260
  if ((ur.questions || ur.updates || ur.connections || max_user_connections) &&
261
      get_or_create_user_conn(thd,user,thd->host_or_ip,&ur))
unknown's avatar
unknown committed
262
    return -1;
unknown's avatar
unknown committed
263 264
  if (thd->user_connect && ((thd->user_connect->user_resources.connections) ||
			    max_user_connections) && 
265
      check_for_max_user_connections(thd->user_connect))
unknown's avatar
unknown committed
266
    return -1;
unknown's avatar
unknown committed
267
  if (db && db[0])
unknown's avatar
unknown committed
268 269
  {
    bool error=test(mysql_change_db(thd,db));
270 271
    if (error && thd->user_connect)
      decrease_user_connections(thd->user_connect);
unknown's avatar
unknown committed
272 273
    return error;
  }
unknown's avatar
unknown committed
274 275
  else
    send_ok(net);				// Ready to handle questions
276
  thd->password= test(passwd[0]);		// Remember for error messages
unknown's avatar
unknown committed
277 278 279
  return 0;					// ok
}

280

unknown's avatar
unknown committed
281
/*
unknown's avatar
unknown committed
282 283
  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
284 285
*/

286 287
extern "C" byte *get_key_conn(user_conn *buff, uint *length,
			      my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
288 289 290 291 292
{
  *length=buff->len;
  return (byte*) buff->user;
}

293
extern "C" void free_user(struct user_conn *uc)
unknown's avatar
unknown committed
294 295 296 297
{
  my_free((char*) uc,MYF(0));
}

unknown's avatar
unknown committed
298 299
void init_max_user_conn(void) 
{
unknown's avatar
unknown committed
300
  (void) hash_init(&hash_user_connections,max_connections,0,0,
301
		   (hash_get_key) get_key_conn, (hash_free_key) free_user,
302
		   0);
unknown's avatar
unknown committed
303 304 305
}


306
static int check_for_max_user_connections(USER_CONN *uc)
unknown's avatar
unknown committed
307
{
308
  int error=0;
309
  DBUG_ENTER("check_for_max_user_connections");
310
  
311
  if (max_user_connections &&
unknown's avatar
unknown committed
312
      (max_user_connections <  (uint) uc->connections))
unknown's avatar
unknown committed
313
  {
314 315 316
    net_printf(&(current_thd->net),ER_TOO_MANY_USER_CONNECTIONS, uc->user);
    error=1;
    goto end;
unknown's avatar
unknown committed
317
  }
318
  uc->connections++; 
319 320
  if (uc->user_resources.connections &&
      uc->conn_per_hour++ >= uc->user_resources.connections)
321
  {
322 323
    net_printf(&current_thd->net, ER_USER_LIMIT_REACHED, uc->user,
	       "max_connections",
324 325 326 327
	       (long) uc->user_resources.connections);
    error=1;
    goto end;
  }
328 329
end:
  DBUG_RETURN(error);
unknown's avatar
unknown committed
330 331 332
}


333
static void decrease_user_connections(USER_CONN *uc)
unknown's avatar
unknown committed
334
{
335
  DBUG_ENTER("decrease_user_connections");
336
  if ((uc->connections && !--uc->connections) && !mqh_used)
unknown's avatar
unknown committed
337 338
  {
    /* Last connection for user; Delete it */
339
    (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
340
    (void) hash_delete(&hash_user_connections,(byte*) uc);
341
    (void) pthread_mutex_unlock(&LOCK_user_conn);
unknown's avatar
unknown committed
342
  }
343
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
344 345
}

346

unknown's avatar
unknown committed
347 348 349 350 351
void free_max_user_conn(void)
{
  hash_free(&hash_user_connections);
}

unknown's avatar
unknown committed
352

353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
/*
  Mark all commands that somehow changes a table
  This is used to check number of updates / hour
*/

char  uc_update_queries[SQLCOM_END];

void init_update_queries(void)
{
  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;
  uc_update_queries[SQLCOM_MULTI_UPDATE]=1;
}


unknown's avatar
unknown committed
385 386 387
/*
  Check if maximum queries per hour limit has been reached
  returns 0 if OK.
unknown's avatar
unknown committed
388

389 390 391
  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
392 393
*/

394

395
static bool check_mqh(THD *thd, uint check_command)
unknown's avatar
unknown committed
396 397
{
  bool error=0;
unknown's avatar
unknown committed
398
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
399
  USER_CONN *uc=thd->user_connect;
unknown's avatar
unknown committed
400
  DBUG_ENTER("check_mqh");
401
  DBUG_ASSERT(uc != 0);
unknown's avatar
unknown committed
402

unknown's avatar
unknown committed
403
  /* If more than a hour since last check, reset resource checking */
404 405 406 407 408 409 410 411 412
  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
413
  /* Check that we have not done too many questions / hour */
414 415 416 417 418 419 420 421
  if (uc->user_resources.questions &&
      uc->questions++ >= uc->user_resources.questions)
  {
    net_printf(&thd->net, ER_USER_LIMIT_REACHED, uc->user, "max_questions",
	       (long) uc->user_resources.questions);
    error=1;
    goto end;
  }
422
  if (check_command < (uint) SQLCOM_END)
unknown's avatar
unknown committed
423
  {
unknown's avatar
unknown committed
424 425 426 427 428 429 430 431 432
    /* 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)
    {
      net_printf(&thd->net, ER_USER_LIMIT_REACHED, uc->user, "max_updates",
		 (long) uc->user_resources.updates);
      error=1;
      goto end;
    }
unknown's avatar
unknown committed
433 434
  }
end:
435
  DBUG_RETURN(error);
unknown's avatar
unknown committed
436 437
}

unknown's avatar
unknown committed
438

unknown's avatar
unknown committed
439
static void reset_mqh(THD *thd, LEX_USER *lu, bool get_them= 0)
440 441
{

unknown's avatar
unknown committed
442
  (void) pthread_mutex_lock(&LOCK_user_conn);
443 444
  if (lu)  // for GRANT 
  {
445
    USER_CONN *uc;
446
    uint temp_len=lu->user.length+lu->host.length+2;
447 448
    char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];

unknown's avatar
unknown committed
449 450
    memcpy(temp_user,lu->user.str,lu->user.length);
    memcpy(temp_user+lu->user.length+1,lu->host.str,lu->host.length);
451
    temp_user[lu->user.length]='\0'; temp_user[temp_len-1]=0;
unknown's avatar
unknown committed
452
    if ((uc = (struct  user_conn *) hash_search(&hash_user_connections,
453
						(byte*) temp_user, temp_len)))
454 455
    {
      uc->questions=0;
456
      get_mqh(temp_user,&temp_user[lu->user.length+1],uc);
457 458
      uc->updates=0;
      uc->conn_per_hour=0;
459 460
    }
  }
461
  else // for FLUSH PRIVILEGES and FLUSH USER_RESOURCES
462
  {
unknown's avatar
unknown committed
463
    for (uint idx=0;idx < hash_user_connections.records; idx++)
464
    {
465 466 467 468 469 470
      USER_CONN *uc=(struct user_conn *) hash_element(&hash_user_connections, idx);
      if (get_them)
	get_mqh(uc->user,uc->host,uc);
      uc->questions=0;
      uc->updates=0;
      uc->conn_per_hour=0;
471 472
    }
  }
unknown's avatar
unknown committed
473
  (void) pthread_mutex_unlock(&LOCK_user_conn);
474
}
unknown's avatar
unknown committed
475

unknown's avatar
unknown committed
476

unknown's avatar
unknown committed
477
/*
unknown's avatar
unknown committed
478 479
  Check connnetion and get priviliges
  Returns 0 on ok, -1 < if error is given > 0 on error.
unknown's avatar
unknown committed
480 481 482 483 484 485 486
*/

static int
check_connections(THD *thd)
{
  uint connect_errors=0;
  NET *net= &thd->net;
unknown's avatar
unknown committed
487
  /* Store the connection details */
unknown's avatar
unknown committed
488 489
  DBUG_PRINT("info", (("check_connections called by thread %d"),
	     thd->thread_id));
unknown's avatar
unknown committed
490
  DBUG_PRINT("info",("New connection received on %s",
unknown's avatar
unknown committed
491 492 493
			vio_description(net->vio)));
  if (!thd->host)                           // If TCP/IP connection
  {
494
    char ip[30];
495

496
    if (vio_peer_addr(net->vio, ip, &thd->peer_port))
unknown's avatar
unknown committed
497 498 499
      return (ER_BAD_HOST_ERROR);
    if (!(thd->ip = my_strdup(ip,MYF(0))))
      return (ER_OUT_OF_RESOURCES);
500
    thd->host_or_ip=thd->ip;
unknown's avatar
unknown committed
501 502 503
#if !defined(HAVE_SYS_UN_H) || defined(HAVE_mit_thread)
    /* Fast local hostname resolve for Win32 */
    if (!strcmp(thd->ip,"127.0.0.1"))
504
      thd->host= thd->host_or_ip= (char*) localhost;
unknown's avatar
unknown committed
505 506 507 508 509 510
    else
#endif
    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);
unknown's avatar
unknown committed
511
      /* Cut very long hostnames to avoid possible overflows */
512
      if (thd->host)
513
      {
514
	thd->host[min(strlen(thd->host), HOSTNAME_LENGTH)]= 0;
515 516
	thd->host_or_ip= thd->host;
      }
unknown's avatar
unknown committed
517 518 519
      if (connect_errors > max_connect_errors)
	return(ER_HOST_IS_BLOCKED);
    }
unknown's avatar
unknown committed
520 521 522
    DBUG_PRINT("info",("Host: %s  ip: %s",
		       thd->host ? thd->host : "unknown host",
		       thd->ip ? thd->ip : "unknown ip"));
unknown's avatar
unknown committed
523 524 525
    if (acl_check_host(thd->host,thd->ip))
      return(ER_HOST_NOT_PRIVILEGED);
  }
526
  else /* Hostname given means that the connection was on a socket */
unknown's avatar
unknown committed
527
  {
unknown's avatar
unknown committed
528
    DBUG_PRINT("info",("Host: %s",thd->host));
529 530
    thd->host_or_ip= thd->host;
    thd->ip= 0;
unknown's avatar
unknown committed
531 532
    bzero((char*) &thd->remote,sizeof(struct sockaddr));
  }
533
  /* Ensure that wrong hostnames doesn't cause buffer overflows */
unknown's avatar
unknown committed
534 535
  vio_keepalive(net->vio, TRUE);

unknown's avatar
unknown committed
536
  ulong pkt_len=0;
unknown's avatar
unknown committed
537
  {
unknown's avatar
unknown committed
538 539
    /* buff[] needs to big enough to hold the server_version variable */
    char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH+32],*end;
540
    int client_flags = CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB;
unknown's avatar
unknown committed
541

542 543 544 545 546
    if (opt_using_transactions)
      client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS
    client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */
unknown's avatar
unknown committed
547 548 549 550
#ifdef HAVE_OPENSSL
    if (ssl_acceptor_fd)
      client_flags |= CLIENT_SSL;       /* Wow, SSL is avalaible! */
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
551

unknown's avatar
unknown committed
552
    end=strnmov(buff,server_version,SERVER_VERSION_LENGTH)+1;
unknown's avatar
unknown committed
553 554 555 556 557
    int4store((uchar*) end,thd->thread_id);
    end+=4;
    memcpy(end,thd->scramble,SCRAMBLE_LENGTH+1);
    end+=SCRAMBLE_LENGTH +1;
    int2store(end,client_flags);
unknown's avatar
unknown committed
558
    end[2]=(char) MY_CHARSET_CURRENT;
unknown's avatar
unknown committed
559 560 561
    int2store(end+3,thd->server_status);
    bzero(end+5,13);
    end+=18;
unknown's avatar
unknown committed
562
    if (net_write_command(net,(uchar) protocol_version, buff,
unknown's avatar
unknown committed
563
			  (uint) (end-buff)) ||
unknown's avatar
unknown committed
564
       (pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
565 566 567 568 569 570 571 572 573 574 575
	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
576
  if (thd->packet.alloc(thd->variables.net_buffer_length))
unknown's avatar
unknown committed
577 578 579
    return(ER_OUT_OF_RESOURCES);

  thd->client_capabilities=uint2korr(net->read_pos);
580 581
  if (thd->client_capabilities & CLIENT_IGNORE_SPACE)
    thd->sql_mode|= MODE_IGNORE_SPACE;
unknown's avatar
unknown committed
582
#ifdef HAVE_OPENSSL
unknown's avatar
unknown committed
583
  DBUG_PRINT("info", ("client capabilities: %d", thd->client_capabilities));
unknown's avatar
unknown committed
584 585 586
  if (thd->client_capabilities & CLIENT_SSL)
  {
    /* Do the SSL layering. */
587 588 589 590 591
    if (!ssl_acceptor_fd)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
unknown's avatar
unknown committed
592
    DBUG_PRINT("info", ("IO layer change in progress..."));
unknown's avatar
unknown committed
593 594 595 596 597 598 599
    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);
      return(ER_HANDSHAKE_ERROR);    
    }
unknown's avatar
unknown committed
600 601 602 603
    DBUG_PRINT("info", ("Reading user information over SSL layer"));
    if ((pkt_len=my_net_read(net)) == packet_error ||
	pkt_len < NORMAL_HANDSHAKE_SIZE)
    {
unknown's avatar
unknown committed
604 605
      DBUG_PRINT("error", ("Failed to read user information (pkt_len= %lu)",
			   pkt_len));
unknown's avatar
unknown committed
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
  }
  else
  {
    DBUG_PRINT("info", ("Leaving IO layer intact"));
    if (pkt_len < NORMAL_HANDSHAKE_SIZE)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return ER_HANDSHAKE_ERROR;
    }
  }
#endif

unknown's avatar
unknown committed
621
  thd->max_client_packet_length=uint3korr(net->read_pos+2);
unknown's avatar
unknown committed
622 623 624 625 626 627
  char *user=   (char*) net->read_pos+5;
  char *passwd= strend(user)+1;
  char *db=0;
  if (thd->client_capabilities & CLIENT_CONNECT_WITH_DB)
    db=strend(passwd)+1;
  if (thd->client_capabilities & CLIENT_INTERACTIVE)
unknown's avatar
unknown committed
628
    thd->variables.net_wait_timeout= thd->variables.net_interactive_timeout;
629 630
  if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
      opt_using_transactions)
unknown's avatar
unknown committed
631
    thd->net.return_status= &thd->server_status;
unknown's avatar
unknown committed
632
  net->read_timeout=(uint) thd->variables.net_read_timeout;
unknown's avatar
unknown committed
633 634 635 636 637 638 639 640 641 642
  if (check_user(thd,COM_CONNECT, user, passwd, db, 1))
    return (-1);
  return 0;
}


pthread_handler_decl(handle_one_connection,arg)
{
  THD *thd=(THD*) arg;
  uint launch_time  =
unknown's avatar
unknown committed
643
    (uint) ((thd->thr_create_time = time(NULL)) - thd->connect_time);
unknown's avatar
unknown committed
644 645 646 647 648
  if (launch_time >= slow_launch_time)
    statistic_increment(slow_launch_threads,&LOCK_status );

  pthread_detach_this_thread();

649 650
#if !defined( __WIN__) && !defined(OS2)	// Win32 calls this in pthread_create
  // The following calls needs to be done before we call DBUG_ macros
651
  if (!(test_flags & TEST_NO_THREADS) & my_thread_init())
unknown's avatar
unknown committed
652 653
  {
    close_connection(&thd->net,ER_OUT_OF_RESOURCES);
654
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
655 656 657 658 659
    end_thread(thd,0);
    return 0;
  }
#endif

660 661 662 663 664 665 666
  /*
    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
667 668 669 670
  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
671
#if defined(__WIN__)
unknown's avatar
unknown committed
672
  init_signals();				// IRENA; testing ?
unknown's avatar
unknown committed
673
#elif !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
674 675 676 677 678 679 680
  sigset_t set;
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
#endif
  if (thd->store_globals())
  {
    close_connection(&thd->net,ER_OUT_OF_RESOURCES);
681
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
682 683 684 685 686 687 688 689 690 691 692 693 694
    end_thread(thd,0);
    return 0;
  }

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

    if ((error=check_connections(thd)))
    {						// Wrong permissions
      if (error > 0)
695
	net_printf(net,error,thd->host_or_ip);
unknown's avatar
unknown committed
696 697 698 699
#ifdef __NT__
      if (vio_type(net->vio) == VIO_TYPE_NAMEDPIPE)
	sleep(1);				/* must wait after eof() */
#endif
700
      statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
701 702
      goto end_thread;
    }
unknown's avatar
unknown committed
703 704 705
#ifdef __NETWARE__
    netware_reg_user(thd->ip, thd->user, "MySQL");
#endif
706
    if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
707 708 709 710
      thd->options |= OPTION_BIG_SELECTS;
    if (thd->client_capabilities & CLIENT_COMPRESS)
      net->compress=1;				// Use compression

unknown's avatar
unknown committed
711
    thd->proc_info=0;				// Remove 'login'
712
    thd->command=COM_SLEEP;
unknown's avatar
unknown committed
713 714
    thd->version=refresh_version;
    thd->set_time();
715 716 717
    init_sql_alloc(&thd->mem_root, MEM_ROOT_BLOCK_SIZE, MEM_ROOT_PREALLOC);
    init_sql_alloc(&thd->transaction.mem_root,
		   TRANS_MEM_ROOT_BLOCK_SIZE, TRANS_MEM_ROOT_PREALLOC);
unknown's avatar
unknown committed
718 719 720 721 722
    while (!net->error && net->vio != 0 && !thd->killed)
    {
      if (do_command(thd))
	break;
    }
723 724
    if (thd->user_connect)
      decrease_user_connections(thd->user_connect);
725
    free_root(&thd->mem_root,MYF(0));
unknown's avatar
unknown committed
726 727
    if (net->error && net->vio != 0)
    {
unknown's avatar
unknown committed
728
      if (!thd->killed && thd->variables.log_warnings)
729 730 731 732 733 734
	sql_print_error(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)));
unknown's avatar
unknown committed
735
      send_error(net,net->last_errno,NullS);
unknown's avatar
unknown committed
736
      statistic_increment(aborted_threads,&LOCK_status);
unknown's avatar
unknown committed
737
    }
738 739 740 741
    else if (thd->killed)
    {
      statistic_increment(aborted_threads,&LOCK_status);
    }
742
    
unknown's avatar
unknown committed
743 744 745 746 747 748 749 750 751 752 753 754 755
end_thread:
    close_connection(net);
    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 */
}

756 757 758 759
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
unknown's avatar
unknown committed
760

761
extern "C" pthread_handler_decl(handle_bootstrap,arg)
unknown's avatar
unknown committed
762
{
763 764 765
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
unknown's avatar
unknown committed
766

767
  /* The following must be called before DBUG_ENTER */
768
  if (my_thread_init() || thd->store_globals())
unknown's avatar
unknown committed
769 770
  {
    close_connection(&thd->net,ER_OUT_OF_RESOURCES);
771 772
    thd->fatal_error=1;
    goto end;
unknown's avatar
unknown committed
773
  }
774 775 776 777
  DBUG_ENTER("handle_bootstrap");

  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
778
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
779
  sigset_t set;
780 781
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
unknown's avatar
unknown committed
782 783
#endif

784
  if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
785 786 787 788
    thd->options |= OPTION_BIG_SELECTS;

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

791
  buff= (char*) thd->net.buff;
792 793 794
  init_sql_alloc(&thd->mem_root, MEM_ROOT_BLOCK_SIZE, MEM_ROOT_PREALLOC);
  init_sql_alloc(&thd->transaction.mem_root,
		 TRANS_MEM_ROOT_BLOCK_SIZE, TRANS_MEM_ROOT_PREALLOC);
unknown's avatar
unknown committed
795 796
  while (fgets(buff, thd->net.max_packet, file))
  {
unknown's avatar
unknown committed
797
    uint length=(uint) strlen(buff);
unknown's avatar
unknown committed
798 799 800 801
    while (length && (isspace(buff[length-1]) || buff[length-1] == ';'))
      length--;
    buff[length]=0;
    thd->current_tablenr=0;
802
    thd->query_length=length;
unknown's avatar
unknown committed
803 804
    thd->query= thd->memdup_w_gap(buff, length+1, thd->db_length+1);
    thd->query[length] = '\0';
unknown's avatar
unknown committed
805
    thd->query_id=query_id++;
806
    if (mqh_used && thd->user_connect && check_mqh(thd, SQLCOM_END))
807 808 809 810 811 812
    {
      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
813 814 815
    mysql_parse(thd,thd->query,length);
    close_thread_tables(thd);			// Free tables
    if (thd->fatal_error)
816
      break;
817
    free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
818
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
unknown's avatar
unknown committed
819
  }
820 821 822 823 824 825

  /* thd->fatal_error should be set in case something went wrong */
end:
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
826
  (void) pthread_cond_broadcast(&COND_thread_count);
827 828 829
  my_thread_end();
  pthread_exit(0);
  DBUG_RETURN(0);				// Never reached
unknown's avatar
unknown committed
830 831 832
}


unknown's avatar
unknown committed
833
inline void free_items(THD *thd)
unknown's avatar
unknown committed
834 835 836 837 838 839 840 841 842 843 844 845 846
{
    /* This works because items are allocated with sql_alloc() */
  for (Item *item=thd->free_list ; item ; item=item->next)
    delete item;
}

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;
847
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
848
    DBUG_RETURN(1); // out of memory
unknown's avatar
unknown committed
849
  table_list->db = db;
850
  table_list->real_name = table_list->alias = tbl_name;
unknown's avatar
unknown committed
851 852 853
  table_list->lock_type = TL_READ_NO_INSERT;
  table_list->next = 0;

854 855 856 857 858
  if (!db || check_db_name(db))
  {
    net_printf(&thd->net,ER_WRONG_DB_NAME, db ? db : "NULL");
    goto err;
  }
859 860 861 862 863 864 865
  if (lower_case_table_names)
    casedn_str(tbl_name);
  remove_escape(tbl_name);

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

866
  if (check_access(thd, SELECT_ACL, db, &table_list->grant.privilege))
unknown's avatar
unknown committed
867
    goto err;
868
  if (grant_option && check_grant(thd, SELECT_ACL, table_list))
unknown's avatar
unknown committed
869 870 871
    goto err;

  thd->free_list = 0;
unknown's avatar
unknown committed
872
  thd->query_length=(uint) strlen(tbl_name);
unknown's avatar
unknown committed
873
  thd->query = tbl_name;
874 875 876 877 878
  if ((error = mysqld_dump_create_info(thd, table, -1)))
  {
    my_error(ER_GET_ERRNO, MYF(0));
    goto err;
  }
unknown's avatar
unknown committed
879
  net_flush(&thd->net);
880
  if ((error= table->file->dump(thd,fd)))
881
    my_error(ER_GET_ERRNO, MYF(0));
unknown's avatar
unknown committed
882

unknown's avatar
unknown committed
883 884
err:
  close_thread_tables(thd);
unknown's avatar
unknown committed
885
  DBUG_RETURN(error);
unknown's avatar
unknown committed
886 887 888 889 890 891 892 893
}


	/* Execute one command from socket (query or simple command) */

bool do_command(THD *thd)
{
  char *packet;
unknown's avatar
unknown committed
894 895
  uint old_timeout;
  ulong packet_length;
unknown's avatar
unknown committed
896 897 898 899 900 901 902 903
  NET *net;
  enum enum_server_command command;
  DBUG_ENTER("do_command");

  net= &thd->net;
  thd->current_tablenr=0;

  packet=0;
unknown's avatar
unknown committed
904 905 906
  old_timeout=net->read_timeout;
  // Wait max for 8 hours
  net->read_timeout=(uint) thd->variables.net_wait_timeout;
unknown's avatar
unknown committed
907 908 909 910 911 912
  net->last_error[0]=0;				// Clear error message
  net->last_errno=0;

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
913 914 915 916 917
    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)
918 919
    {
      statistic_increment(aborted_threads,&LOCK_status);
920
      DBUG_RETURN(TRUE);			// We have to close it.
921
    }
922
    send_error(net,net->last_errno,NullS);
923
    net->error= 0;
924 925
    DBUG_RETURN(FALSE);
  }
unknown's avatar
unknown committed
926 927 928 929
  else
  {
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
930 931
    if (command >= COM_END)
      command= COM_END;				// Wrong command
unknown's avatar
unknown committed
932 933 934
    DBUG_PRINT("info",("Command on %s = %d (%s)",
		       vio_description(net->vio), command,
		       command_name[command]));
unknown's avatar
unknown committed
935
  }
unknown's avatar
unknown committed
936
  net->read_timeout=old_timeout;		// restore it
unknown's avatar
unknown committed
937
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
938 939 940 941 942 943 944 945
}


bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
  bool	error=0;
unknown's avatar
unknown committed
946 947 948 949
  /*
    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
  */
950 951 952
  bool slow_command=FALSE;
  DBUG_ENTER("dispatch_command");

unknown's avatar
unknown committed
953
  thd->command=command;
unknown's avatar
unknown committed
954
  thd->set_time();
unknown's avatar
unknown committed
955 956 957 958 959 960
  VOID(pthread_mutex_lock(&LOCK_thread_count));
  thd->query_id=query_id;
  if (command != COM_STATISTICS && command != COM_PING)
    query_id++;
  thread_running++;
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
961

962
  thd->lex.select_lex.options=0;		// We store status here
963
  switch (command) {
unknown's avatar
unknown committed
964
  case COM_INIT_DB:
unknown's avatar
unknown committed
965
    statistic_increment(com_stat[SQLCOM_CHANGE_DB],&LOCK_status);
966
    if (!mysql_change_db(thd,packet))
967
      mysql_log.write(thd,command,"%s",thd->db);
unknown's avatar
unknown committed
968
    break;
969 970
  case COM_REGISTER_SLAVE:
  {
971
    if (!register_slave(thd, (uchar*)packet, packet_length))
972 973 974
      send_ok(&thd->net);
    break;
  }
unknown's avatar
unknown committed
975 976
  case COM_TABLE_DUMP:
    {
unknown's avatar
unknown committed
977
      statistic_increment(com_other, &LOCK_status);
978
      slow_command = TRUE;
979 980
      uint db_len = *(uchar*)packet;
      uint tbl_len = *(uchar*)(packet + db_len + 1);
981
      char* db = thd->alloc(db_len + tbl_len + 2);
982
      memcpy(db, packet + 1, db_len);
unknown's avatar
unknown committed
983 984
      char* tbl_name = db + db_len;
      *tbl_name++ = 0;
985
      memcpy(tbl_name, packet + db_len + 2, tbl_len);
unknown's avatar
unknown committed
986
      tbl_name[tbl_len] = 0;
unknown's avatar
unknown committed
987
      if (mysql_table_dump(thd, db, tbl_name, -1))
unknown's avatar
unknown committed
988 989 990 991 992
	send_error(&thd->net); // dump to NET
      break;
    }
  case COM_CHANGE_USER:
  {
unknown's avatar
unknown committed
993 994 995 996
    thd->change_user();
    clear_error_message(thd);			// If errors from rollback

    statistic_increment(com_other,&LOCK_status);
997
    char *user=   (char*) packet;
unknown's avatar
unknown committed
998 999 1000 1001 1002 1003
    char *passwd= strend(user)+1;
    char *db=     strend(passwd)+1;

    /* Save user and privileges */
    uint save_master_access=thd->master_access;
    uint save_db_access=    thd->db_access;
unknown's avatar
unknown committed
1004
    uint save_db_length=    thd->db_length;
unknown's avatar
unknown committed
1005 1006 1007
    char *save_user=	    thd->user;
    char *save_priv_user=   thd->priv_user;
    char *save_db=	    thd->db;
1008
    thd->user=0;
1009
    USER_CONN *save_uc=            thd->user_connect;
unknown's avatar
unknown committed
1010 1011 1012 1013 1014 1015

    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
    {						// Check if protocol is ok
      send_error(net, ER_UNKNOWN_COM_ERROR);
      break;
    }
unknown's avatar
unknown committed
1016
    if (check_user(thd, COM_CHANGE_USER, user, passwd, db, 0))
unknown's avatar
unknown committed
1017 1018 1019 1020 1021
    {						// Restore old user
      x_free(thd->user);
      thd->master_access=save_master_access;
      thd->db_access=save_db_access;
      thd->db=save_db;
unknown's avatar
unknown committed
1022
      thd->db_length=save_db_length;
unknown's avatar
unknown committed
1023 1024 1025 1026
      thd->user=save_user;
      thd->priv_user=save_priv_user;
      break;
    }
1027
    if (max_connections && save_uc)
unknown's avatar
unknown committed
1028
      decrease_user_connections(save_uc);
unknown's avatar
unknown committed
1029 1030 1031 1032 1033 1034 1035
    x_free((gptr) save_db);
    x_free((gptr) save_user);
    break;
  }

  case COM_QUERY:
  {
1036 1037 1038 1039 1040 1041 1042 1043
    packet_length--;				// Remove end null
    /* Remove garage at start and end of query */
    while (isspace(packet[0]) && packet_length > 0)
    {
      packet++;
      packet_length--;
    }
    char *pos=packet+packet_length;		// Point at end null
1044
    while (packet_length > 0 && (pos[-1] == ';' || isspace(pos[-1])))
unknown's avatar
unknown committed
1045 1046 1047 1048
    {
      pos--;
      packet_length--;
    }
1049
    /* We must allocate some extra memory for query cache */
unknown's avatar
unknown committed
1050
    if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
1051
						packet_length,
1052 1053
						thd->db_length+2+
						sizeof(ha_rows))))
unknown's avatar
unknown committed
1054
      break;
unknown's avatar
unknown committed
1055
    thd->query[packet_length]=0;
unknown's avatar
unknown committed
1056
    thd->packet.shrink(thd->variables.net_buffer_length);// Reclaim some memory
unknown's avatar
unknown committed
1057 1058
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),QUERY_PRIOR);
1059
    mysql_log.write(thd,command,"%s",thd->query);
1060
    DBUG_PRINT("query",("%-.4096s",thd->query));
1061 1062
    /* thd->query_length is set by mysql_parse() */
    mysql_parse(thd,thd->query,packet_length);
unknown's avatar
unknown committed
1063 1064 1065 1066 1067
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1068
  case COM_FIELD_LIST:				// This isn't actually needed
unknown's avatar
unknown committed
1069 1070 1071 1072 1073 1074 1075
#ifdef DONT_ALLOW_SHOW_COMMANDS
    send_error(&thd->net,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
    break;
#else
  {
    char *fields;
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1076
    statistic_increment(com_stat[SQLCOM_SHOW_FIELDS],&LOCK_status);
unknown's avatar
unknown committed
1077 1078 1079 1080 1081 1082 1083
    bzero((char*) &table_list,sizeof(table_list));
    if (!(table_list.db=thd->db))
    {
      send_error(net,ER_NO_DB_ERROR);
      break;
    }
    thd->free_list=0;
1084
    table_list.alias= table_list.real_name= thd->strdup(packet);
unknown's avatar
unknown committed
1085
    packet=strend(packet)+1;
unknown's avatar
unknown committed
1086
    // command not cachable => no gap for data base name
unknown's avatar
unknown committed
1087 1088
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1089
    mysql_log.write(thd,command,"%s %s",table_list.real_name,fields);
1090 1091
    if (lower_case_table_names)
      casedn_str(table_list.real_name);
unknown's avatar
unknown committed
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
    remove_escape(table_list.real_name);	// This can't have wildcards

    if (check_access(thd,SELECT_ACL,table_list.db,&thd->col_access))
      break;
    table_list.grant.privilege=thd->col_access;
    if (grant_option && check_grant(thd,SELECT_ACL,&table_list,2))
      break;
    mysqld_list_fields(thd,&table_list,fields);
    free_items(thd);
    break;
  }
#endif
  case COM_QUIT:
1105
    /* We don't calculate statistics for this command */
1106
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1107 1108 1109 1110
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

unknown's avatar
unknown committed
1111
  case COM_CREATE_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1112
    {
unknown's avatar
unknown committed
1113
      statistic_increment(com_stat[SQLCOM_CREATE_DB],&LOCK_status);
1114
      char *db=thd->strdup(packet);
1115
      // null test to handle EOM
unknown's avatar
unknown committed
1116
      if (!db || !strip_sp(db) || check_db_name(db))
1117 1118 1119 1120
      {
	net_printf(&thd->net,ER_WRONG_DB_NAME, db ? db : "NULL");
	break;
      }
unknown's avatar
unknown committed
1121 1122
      if (check_access(thd,CREATE_ACL,db,0,1))
	break;
1123
      mysql_log.write(thd,command,packet);
unknown's avatar
unknown committed
1124
      mysql_create_db(thd,db,0,0);
unknown's avatar
unknown committed
1125 1126
      break;
    }
unknown's avatar
unknown committed
1127
  case COM_DROP_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1128
    {
unknown's avatar
unknown committed
1129
      statistic_increment(com_stat[SQLCOM_DROP_DB],&LOCK_status);
1130
      char *db=thd->strdup(packet);
1131
      // null test to handle EOM
unknown's avatar
unknown committed
1132
      if (!db || !strip_sp(db) || check_db_name(db))
1133 1134 1135 1136
      {
	net_printf(&thd->net,ER_WRONG_DB_NAME, db ? db : "NULL");
	break;
      }
1137 1138
      if (check_access(thd,DROP_ACL,db,0,1))
	break;
unknown's avatar
unknown committed
1139 1140 1141
      if (thd->locked_tables || thd->active_transaction())
      {
	send_error(&thd->net,ER_LOCK_OR_ACTIVE_TRANSACTION);
unknown's avatar
unknown committed
1142
	break;
unknown's avatar
unknown committed
1143
      }
1144
      mysql_log.write(thd,command,db);
unknown's avatar
unknown committed
1145
      mysql_rm_db(thd,db,0,0);
unknown's avatar
unknown committed
1146 1147 1148 1149
      break;
    }
  case COM_BINLOG_DUMP:
    {
unknown's avatar
unknown committed
1150
      statistic_increment(com_other,&LOCK_status);
1151
      slow_command = TRUE;
unknown's avatar
unknown committed
1152
      if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1153
	break;
1154
      mysql_log.write(thd,command, 0);
unknown's avatar
unknown committed
1155

unknown's avatar
unknown committed
1156 1157
      ulong pos;
      ushort flags;
1158
      uint32 slave_server_id;
1159
      /* TODO: The following has to be changed to an 8 byte integer */
1160 1161
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
unknown's avatar
unknown committed
1162
      thd->server_id=0; /* avoid suicide */
unknown's avatar
unknown committed
1163
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
unknown's avatar
unknown committed
1164
	kill_zombie_dump_threads(slave_server_id);
1165
      thd->server_id = slave_server_id;
1166
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
unknown's avatar
unknown committed
1167
      unregister_slave(thd,1,1);
1168 1169 1170
      // fake COM_QUIT -- if we get here, the thread needs to terminate
      error = TRUE;
      net->error = 0;
unknown's avatar
unknown committed
1171 1172 1173 1174
      break;
    }
  case COM_REFRESH:
    {
unknown's avatar
unknown committed
1175
      statistic_increment(com_stat[SQLCOM_FLUSH],&LOCK_status);
unknown's avatar
unknown committed
1176
      ulong options= (ulong) (uchar) packet[0];
unknown's avatar
unknown committed
1177
      if (check_global_access(thd,RELOAD_ACL))
unknown's avatar
unknown committed
1178
	break;
1179
      mysql_log.write(thd,command,NullS);
1180 1181
      /* error sending is deferred to reload_acl_and_cache */
      reload_acl_and_cache(thd, options, (TABLE_LIST*) 0) ;
unknown's avatar
unknown committed
1182 1183 1184
      break;
    }
  case COM_SHUTDOWN:
unknown's avatar
unknown committed
1185
    statistic_increment(com_other,&LOCK_status);
unknown's avatar
unknown committed
1186
    if (check_global_access(thd,SHUTDOWN_ACL))
unknown's avatar
unknown committed
1187 1188
      break; /* purecov: inspected */
    DBUG_PRINT("quit",("Got shutdown command"));
1189
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1190 1191 1192 1193
    send_eof(net);
#ifdef __WIN__
    sleep(1);					// must wait after eof()
#endif
unknown's avatar
unknown committed
1194
#ifndef OS2
unknown's avatar
unknown committed
1195
    send_eof(net);				// This is for 'quit request'
unknown's avatar
unknown committed
1196
#endif
unknown's avatar
unknown committed
1197 1198
    close_connection(net);
    close_thread_tables(thd);			// Free before kill
1199
    free_root(&thd->mem_root,MYF(0));
1200
    free_root(&thd->transaction.mem_root,MYF(0));
unknown's avatar
unknown committed
1201 1202 1203 1204 1205 1206
    kill_mysql();
    error=TRUE;
    break;

  case COM_STATISTICS:
  {
1207
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1208
    statistic_increment(com_stat[SQLCOM_SHOW_STATUS],&LOCK_status);
unknown's avatar
unknown committed
1209
    char buff[200];
1210
    ulong uptime = (ulong) (thd->start_time - start_time);
unknown's avatar
unknown committed
1211
    sprintf((char*) buff,
1212
	    "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
1213 1214 1215 1216 1217
	    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
1218
    if (sf_malloc_cur_memory)				// Using SAFEMALLOC
unknown's avatar
unknown committed
1219
      sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
1220 1221
	      (sf_malloc_cur_memory+1023L)/1024L,
	      (sf_malloc_max_memory+1023L)/1024L);
unknown's avatar
unknown committed
1222
 #endif
unknown's avatar
unknown committed
1223
    VOID(my_net_write(net, buff,(uint) strlen(buff)));
unknown's avatar
unknown committed
1224 1225 1226 1227
    VOID(net_flush(net));
    break;
  }
  case COM_PING:
unknown's avatar
unknown committed
1228
    statistic_increment(com_other,&LOCK_status);
unknown's avatar
unknown committed
1229 1230 1231
    send_ok(net);				// Tell client we are alive
    break;
  case COM_PROCESS_INFO:
unknown's avatar
unknown committed
1232
    statistic_increment(com_stat[SQLCOM_SHOW_PROCESSLIST],&LOCK_status);
unknown's avatar
unknown committed
1233
    if (!thd->priv_user[0] && check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
1234
      break;
1235
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1236 1237 1238 1239 1240
    mysqld_list_processes(thd,thd->master_access & PROCESS_ACL ? NullS :
			  thd->priv_user,0);
    break;
  case COM_PROCESS_KILL:
  {
unknown's avatar
unknown committed
1241
    statistic_increment(com_stat[SQLCOM_KILL],&LOCK_status);
1242
    ulong id=(ulong) uint4korr(packet);
unknown's avatar
unknown committed
1243 1244 1245 1246
    kill_one_thread(thd,id);
    break;
  }
  case COM_DEBUG:
unknown's avatar
unknown committed
1247
    statistic_increment(com_other,&LOCK_status);
unknown's avatar
unknown committed
1248
    if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
1249 1250
      break;					/* purecov: inspected */
    mysql_print_status(thd);
1251
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1252 1253 1254 1255 1256 1257
    send_eof(net);
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
1258
  case COM_END:
unknown's avatar
unknown committed
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
  default:
    send_error(net, ER_UNKNOWN_COM_ERROR);
    break;
  }
  if (thd->lock || thd->open_tables)
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }

  if (thd->fatal_error)
    send_error(net,0);				// End of memory ?

  time_t start_of_query=thd->start_time;
1273
  thd->end_time();				// Set start time
1274

1275
  /* If not reading from backup and if the query took too long */
1276
  if (!slow_command && !thd->user_time) // do not log 'slow_command' queries
unknown's avatar
unknown committed
1277
  {
1278 1279
    thd->proc_info="logging slow query";

1280 1281
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
1282
	((thd->lex.select_lex.options &
1283
	  (QUERY_NO_INDEX_USED | QUERY_NO_GOOD_INDEX_USED)) &&
1284
	 (specialflag & SPECIAL_LONG_LOG_FORMAT)))
1285 1286 1287 1288
    {
      long_query_count++;
      mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
    }
unknown's avatar
unknown committed
1289
  }
1290
  thd->proc_info="cleaning up";
unknown's avatar
unknown committed
1291 1292 1293 1294 1295 1296
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
  thd->proc_info=0;
  thd->command=COM_SLEEP;
  thd->query=0;
  thread_running--;
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1297
  thd->packet.shrink(thd->variables.net_buffer_length);	// Reclaim some memory
1298
  free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
unknown's avatar
unknown committed
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
  DBUG_RETURN(error);
}

/****************************************************************************
** mysql_execute_command
** Execute command saved in thd and current_lex->sql_command
****************************************************************************/

void
mysql_execute_command(void)
{
  int	res=0;
  THD	*thd=current_thd;
1312
  LEX	*lex= &thd->lex;
1313
  TABLE_LIST *tables=(TABLE_LIST*) lex->select_lex.table_list.first;
1314
  SELECT_LEX *select_lex = lex->select;
unknown's avatar
unknown committed
1315 1316
  DBUG_ENTER("mysql_execute_command");

1317 1318
  if (thd->slave_thread)
  {
unknown's avatar
merge  
unknown committed
1319 1320 1321 1322 1323
    /* 
      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
    */
    if (table_rules_on && tables && !tables_ok(thd,tables))
1324
      DBUG_VOID_RETURN;
unknown's avatar
merge  
unknown committed
1325 1326 1327 1328 1329 1330
#ifndef TO_BE_DELETED
    /*
       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()
    */
1331 1332 1333
    if (lex->sql_command == SQLCOM_SELECT)
    {
      lex->sql_command = SQLCOM_DO;
unknown's avatar
unknown committed
1334
      lex->insert_list = &select_lex->item_list;
1335
    }
unknown's avatar
merge  
unknown committed
1336
#endif
1337
  }
1338
  
1339 1340 1341 1342
  /*
    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
  */
unknown's avatar
unknown committed
1343 1344 1345
  if ((lex->select_lex.next && create_total_list(thd,lex,&tables)) ||
      (table_rules_on && tables && thd->slave_thread &&
       !tables_ok(thd,tables)))
1346
    DBUG_VOID_RETURN;
1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
  
  /*
    When option readonly is set deny operations which change tables.
    Except for the replication thread and the 'super' users.
  */
  if (opt_readonly &&
      !(thd->slave_thread || (thd->master_access & SUPER_ACL)) &&
      (uc_update_queries[lex->sql_command] > 0))
  {
    send_error(&thd->net,ER_CANT_UPDATE_WITH_READLOCK);
    DBUG_VOID_RETURN;
  }
1359

unknown's avatar
unknown committed
1360
  statistic_increment(com_stat[lex->sql_command],&LOCK_status);
unknown's avatar
unknown committed
1361 1362 1363 1364
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
    select_result *result;
1365
    if (select_lex->options & SELECT_DESCRIBE)
unknown's avatar
unknown committed
1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
      lex->exchange=0;
    if (tables)
    {
      res=check_table_access(thd,
			     lex->exchange ? SELECT_ACL | FILE_ACL :
			     SELECT_ACL,
			     tables);
    }
    else
      res=check_access(thd, lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
		       any_db);
    if (res)
    {
      res=0;
      break;					// Error message is given
    }

1383 1384 1385
    thd->offset_limit=select_lex->offset_limit;
    thd->select_limit=select_lex->select_limit+select_lex->offset_limit;
    if (thd->select_limit < select_lex->select_limit)
unknown's avatar
unknown committed
1386
      thd->select_limit= HA_POS_ERROR;		// no limit
1387
    if (thd->select_limit == HA_POS_ERROR)
1388
      select_lex->options&= ~OPTION_FOUND_ROWS;
unknown's avatar
unknown committed
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412

    if (lex->exchange)
    {
      if (lex->exchange->dumpfile)
      {
	if (!(result=new select_dump(lex->exchange)))
	{
	  res= -1;
	  break;
	}
      }
      else
      {
	if (!(result=new select_export(lex->exchange)))
	{
	  res= -1;
	  break;
	}
      }
    }
    else if (!(result=new select_send()))
    {
      res= -1;
#ifdef DELETE_ITEMS
1413 1414
      delete select_lex->having;
      delete select_lex->where;
unknown's avatar
unknown committed
1415 1416 1417
#endif
      break;
    }
unknown's avatar
unknown committed
1418
    else
unknown's avatar
unknown committed
1419
    {
unknown's avatar
unknown committed
1420 1421 1422 1423
      /*
	Normal select:
	Change lock if we are using SELECT HIGH PRIORITY,
	FOR UPDATE or IN SHARE MODE
unknown's avatar
unknown committed
1424 1425

	TODO: Delete the following loop when locks is set by sql_yacc
unknown's avatar
unknown committed
1426
      */
unknown's avatar
unknown committed
1427 1428
      TABLE_LIST *table;
      for (table = tables ; table ; table=table->next)
unknown's avatar
unknown committed
1429
	table->lock_type= lex->lock_option;
unknown's avatar
unknown committed
1430 1431 1432
    }

    if (!(res=open_and_lock_tables(thd,tables)))
unknown's avatar
unknown committed
1433
    {
unknown's avatar
unknown committed
1434
      query_cache_store_query(thd, tables);
1435
      res=handle_select(thd, lex, result);
unknown's avatar
unknown committed
1436
    }
1437 1438
    else
      delete result;
unknown's avatar
unknown committed
1439 1440
    break;
  }
unknown's avatar
unknown committed
1441 1442 1443 1444
  case SQLCOM_DO:
    res=mysql_do(thd, *lex->insert_list);
    break;

1445 1446 1447 1448
  case SQLCOM_EMPTY_QUERY:
    send_ok(&thd->net);
    break;

unknown's avatar
unknown committed
1449
  case SQLCOM_PURGE:
1450
  {
unknown's avatar
unknown committed
1451
    if (check_global_access(thd, SUPER_ACL))
1452 1453 1454 1455
      goto error;
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
unknown's avatar
unknown committed
1456 1457
  case SQLCOM_SHOW_NEW_MASTER:
  {
unknown's avatar
unknown committed
1458
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1459
      goto error;
unknown's avatar
unknown committed
1460 1461 1462 1463
#ifndef WORKING_NEW_MASTER
    net_printf(&thd->net, ER_NOT_SUPPORTED_YET, "SHOW NEW MASTER");
    res= 1;
#else
unknown's avatar
unknown committed
1464
    res = show_new_master(thd);
unknown's avatar
unknown committed
1465
#endif
unknown's avatar
unknown committed
1466 1467
    break;
  }
1468 1469
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
unknown's avatar
unknown committed
1470
    if (check_global_access(thd, REPL_SLAVE_ACL))
1471 1472 1473 1474
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
unknown's avatar
unknown committed
1475 1476
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
unknown's avatar
unknown committed
1477
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1478 1479 1480 1481
      goto error;
    res = show_binlog_events(thd);
    break;
  }
unknown's avatar
unknown committed
1482
  case SQLCOM_BACKUP_TABLE:
1483 1484 1485
  {
    if (check_db_used(thd,tables) ||
	check_table_access(thd,SELECT_ACL, tables) ||
unknown's avatar
unknown committed
1486
	check_global_access(thd, FILE_ACL))
1487 1488
      goto error; /* purecov: inspected */
    res = mysql_backup_table(thd, tables);
unknown's avatar
unknown committed
1489

1490 1491
    break;
  }
unknown's avatar
unknown committed
1492
  case SQLCOM_RESTORE_TABLE:
1493 1494
  {
    if (check_db_used(thd,tables) ||
unknown's avatar
unknown committed
1495 1496
	check_table_access(thd, INSERT_ACL, tables) ||
	check_global_access(thd, FILE_ACL))
1497 1498 1499 1500
      goto error; /* purecov: inspected */
    res = mysql_restore_table(thd, tables);
    break;
  }
unknown's avatar
unknown committed
1501
  case SQLCOM_CHANGE_MASTER:
1502
  {
unknown's avatar
unknown committed
1503
    if (check_global_access(thd, SUPER_ACL))
1504
      goto error;
1505 1506 1507
    LOCK_ACTIVE_MI;
    res = change_master(thd,active_mi);
    UNLOCK_ACTIVE_MI;
1508 1509
    break;
  }
unknown's avatar
unknown committed
1510
  case SQLCOM_SHOW_SLAVE_STAT:
1511
  {
1512 1513
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
1514
      goto error;
1515 1516 1517
    LOCK_ACTIVE_MI;
    res = show_master_info(thd,active_mi);
    UNLOCK_ACTIVE_MI;
1518 1519
    break;
  }
unknown's avatar
unknown committed
1520
  case SQLCOM_SHOW_MASTER_STAT:
1521
  {
1522 1523
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
1524 1525 1526 1527
      goto error;
    res = show_binlog_info(thd);
    break;
  }
1528 1529
    
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
unknown's avatar
unknown committed
1530
    if (check_global_access(thd, SUPER_ACL))
1531
      goto error;
1532 1533 1534 1535
    if (end_active_trans(thd))
      res= -1;
    else
      res = load_master_data(thd);
1536 1537
    break;
    
unknown's avatar
unknown committed
1538 1539 1540
#ifdef HAVE_INNOBASE_DB
  case SQLCOM_SHOW_INNODB_STATUS:
    {
1541
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
1542 1543 1544 1545 1546
	goto error;
      res = innodb_show_status(thd);
      break;
    }
#endif
unknown's avatar
unknown committed
1547

unknown's avatar
unknown committed
1548
  case SQLCOM_LOAD_MASTER_TABLE:
1549
  {
unknown's avatar
unknown committed
1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
    if (!tables->db)
      tables->db=thd->db;
    if (check_access(thd,CREATE_ACL,tables->db,&tables->grant.privilege))
      goto error;				/* purecov: inspected */
    if (grant_option)
    {
      /* Check that the first table has CREATE privilege */
      TABLE_LIST *tmp_table_list=tables->next;
      tables->next=0;
      bool error=check_grant(thd,CREATE_ACL,tables);
      tables->next=tmp_table_list;
      if (error)
1562
	goto error;
unknown's avatar
unknown committed
1563
    }
1564 1565 1566 1567 1568 1569 1570 1571
    LOCK_ACTIVE_MI;
    // fetch_master_table will send the error to the client on failure
    if (!fetch_master_table(thd, tables->db, tables->real_name,
			    active_mi, 0))
    {
      send_ok(&thd->net);
    }
    UNLOCK_ACTIVE_MI;
unknown's avatar
unknown committed
1572
    break;
1573
  }
unknown's avatar
unknown committed
1574
  case SQLCOM_CREATE_TABLE:
unknown's avatar
unknown committed
1575 1576 1577
  {
    ulong want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
		      CREATE_TMP_ACL : CREATE_ACL);
1578 1579
    if (!tables->db)
      tables->db=thd->db;
unknown's avatar
unknown committed
1580
    if (check_access(thd,want_priv,tables->db,&tables->grant.privilege) ||
1581 1582 1583
	check_merge_table_access(thd, tables->db,
				 (TABLE_LIST *)
				 lex->create_info.merge_list.first))
unknown's avatar
unknown committed
1584
      goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
1585
    if (grant_option && want_priv != CREATE_TMP_ACL)
unknown's avatar
unknown committed
1586 1587 1588 1589
    {
      /* Check that the first table has CREATE privilege */
      TABLE_LIST *tmp_table_list=tables->next;
      tables->next=0;
unknown's avatar
unknown committed
1590
      bool error=check_grant(thd, want_priv, tables);
unknown's avatar
unknown committed
1591 1592 1593 1594
      tables->next=tmp_table_list;
      if (error)
	goto error;
    }
1595
    if (strlen(tables->real_name) > NAME_LEN)
unknown's avatar
unknown committed
1596
    {
1597
      net_printf(&thd->net, ER_WRONG_TABLE_NAME, tables->alias);
unknown's avatar
unknown committed
1598 1599 1600
      res=0;
      break;
    }
1601 1602 1603
#ifndef HAVE_READLINK
    lex->create_info.data_file_name=lex->create_info.index_file_name=0;
#else
1604
    /* Fix names if symlinked tables */
unknown's avatar
unknown committed
1605
    if (append_file_to_dir(thd, &lex->create_info.data_file_name,
1606
			   tables->real_name) ||
unknown's avatar
unknown committed
1607
	append_file_to_dir(thd,&lex->create_info.index_file_name,
1608
			   tables->real_name))
1609 1610 1611 1612
    {
      res=-1;
      break;
    }
1613
#endif
1614
    if (select_lex->item_list.elements)		// With select
unknown's avatar
unknown committed
1615 1616 1617 1618
    {
      select_result *result;

      if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) &&
unknown's avatar
unknown committed
1619
	  check_dup(tables->db, tables->real_name, tables->next))
unknown's avatar
unknown committed
1620 1621 1622 1623 1624 1625
      {
	net_printf(&thd->net,ER_INSERT_TABLE_USED,tables->real_name);
	DBUG_VOID_RETURN;
      }
      if (tables->next)
      {
1626
	TABLE_LIST *table;
unknown's avatar
unknown committed
1627 1628
	if (check_table_access(thd, SELECT_ACL, tables->next))
	  goto error;				// Error message is given
unknown's avatar
unknown committed
1629
	/* TODO: Delete the following loop when locks is set by sql_yacc */
1630 1631
	for (table = tables->next ; table ; table=table->next)
	  table->lock_type= lex->lock_option;
unknown's avatar
unknown committed
1632
      }
1633
      select_lex->options|= SELECT_NO_UNLOCK;
1634 1635 1636
      thd->offset_limit=select_lex->offset_limit;
      thd->select_limit=select_lex->select_limit+select_lex->offset_limit;
      if (thd->select_limit < select_lex->select_limit)
unknown's avatar
unknown committed
1637
	thd->select_limit= HA_POS_ERROR;		// No limit
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653

      /* Skip first table, which is the table we are creating */
      lex->select_lex.table_list.first=
	(byte*) (((TABLE_LIST *) lex->select_lex.table_list.first)->next);
      if (!(res=open_and_lock_tables(thd,tables->next)))
      {
        if ((result=new select_create(tables->db ? tables->db : thd->db,
                                      tables->real_name, &lex->create_info,
                                      lex->create_list,
                                      lex->key_list,
                                      select_lex->item_list,lex->duplicates)))
          res=handle_select(thd, lex, result);
	else
	  res= -1;
      }
    }
unknown's avatar
unknown committed
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663
    else // regular create
    {
      res = mysql_create_table(thd,tables->db ? tables->db : thd->db,
			       tables->real_name, &lex->create_info,
			       lex->create_list,
			       lex->key_list,0, 0); // do logging
      if (!res)
	send_ok(&thd->net);
    }
    break;
unknown's avatar
unknown committed
1664
  }
unknown's avatar
unknown committed
1665 1666 1667 1668 1669 1670 1671
  case SQLCOM_CREATE_INDEX:
    if (!tables->db)
      tables->db=thd->db;
    if (check_access(thd,INDEX_ACL,tables->db,&tables->grant.privilege))
      goto error; /* purecov: inspected */
    if (grant_option && check_grant(thd,INDEX_ACL,tables))
      goto error;
1672 1673 1674 1675
    if (end_active_trans(thd))
      res= -1;
    else
      res = mysql_create_index(thd, tables, lex->key_list);
unknown's avatar
unknown committed
1676 1677 1678
    break;

  case SQLCOM_SLAVE_START:
1679 1680 1681 1682
  {
    LOCK_ACTIVE_MI;
    start_slave(thd,active_mi,1 /* net report*/);
    UNLOCK_ACTIVE_MI;
unknown's avatar
unknown committed
1683
    break;
1684
  }
unknown's avatar
unknown committed
1685
  case SQLCOM_SLAVE_STOP:
1686 1687 1688 1689 1690 1691
  /*
    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,
1692
      so it waits for the client thread because t is locked by it.
1693
    - then the client thread does SLAVE STOP.
1694 1695
      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.
1696 1697 1698 1699 1700 1701
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
  if (thd->locked_tables || thd->active_transaction())
  {
    send_error(&thd->net,ER_LOCK_OR_ACTIVE_TRANSACTION);
unknown's avatar
unknown committed
1702
    break;
1703
  }
1704 1705 1706 1707
  {
    LOCK_ACTIVE_MI;
    stop_slave(thd,active_mi,1/* net report*/);
    UNLOCK_ACTIVE_MI;
unknown's avatar
unknown committed
1708
    break;
1709
  }
unknown's avatar
unknown committed
1710 1711 1712 1713 1714 1715
  case SQLCOM_ALTER_TABLE:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
    send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
    break;
#else
    {
unknown's avatar
unknown committed
1716
      ulong priv=0;
unknown's avatar
unknown committed
1717
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
unknown's avatar
unknown committed
1718 1719 1720 1721 1722
      {
	net_printf(&thd->net,ER_WRONG_TABLE_NAME,lex->name);
	res=0;
	break;
      }
1723 1724
      if (!tables->db)
	tables->db=thd->db;
1725 1726
      if (!select_lex->db)
	select_lex->db=tables->db;
unknown's avatar
unknown committed
1727
      if (check_access(thd,ALTER_ACL,tables->db,&tables->grant.privilege) ||
1728
	  check_access(thd,INSERT_ACL | CREATE_ACL,select_lex->db,&priv) ||
1729 1730 1731 1732
	  check_merge_table_access(thd, tables->db, 
				   (TABLE_LIST *)
				   lex->create_info.merge_list.first))
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
      if (!tables->db)
	tables->db=thd->db;
      if (grant_option)
      {
	if (check_grant(thd,ALTER_ACL,tables))
	  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;
1744
	  tmp_table.db=select_lex->db;
unknown's avatar
unknown committed
1745 1746 1747 1748 1749
	  tmp_table.grant.privilege=priv;
	  if (check_grant(thd,INSERT_ACL | CREATE_ACL,tables))
	    goto error;
	}
      }
1750 1751
      /* 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
1752
      /* ALTER TABLE ends previous transaction */
1753
      if (end_active_trans(thd))
unknown's avatar
unknown committed
1754 1755
	res= -1;
      else
unknown's avatar
unknown committed
1756
      {
1757
	res= mysql_alter_table(thd, select_lex->db, lex->name,
unknown's avatar
unknown committed
1758 1759 1760
			       &lex->create_info,
			       tables, lex->create_list,
			       lex->key_list, lex->drop_list, lex->alter_list,
1761
                               (ORDER *) select_lex->order_list.first,
1762 1763
			       lex->drop_primary, lex->duplicates,
			       lex->alter_keys_onoff, lex->simple_alter);
unknown's avatar
unknown committed
1764
      }
unknown's avatar
unknown committed
1765 1766 1767
      break;
    }
#endif
unknown's avatar
unknown committed
1768
  case SQLCOM_RENAME_TABLE:
unknown's avatar
unknown committed
1769 1770 1771
  {
    TABLE_LIST *table;
    if (check_db_used(thd,tables))
unknown's avatar
unknown committed
1772
      goto error;
unknown's avatar
unknown committed
1773 1774
    for (table=tables ; table ; table=table->next->next)
    {
unknown's avatar
unknown committed
1775 1776
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
		       &table->grant.privilege) ||
unknown's avatar
unknown committed
1777 1778 1779 1780 1781
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next->db,
		       &table->next->grant.privilege))
	goto error;
      if (grant_option)
      {
unknown's avatar
unknown committed
1782 1783 1784 1785 1786
	TABLE_LIST old_list,new_list;
	old_list=table[0];
	new_list=table->next[0];
	old_list.next=new_list.next=0;
	if (check_grant(thd,ALTER_ACL,&old_list) ||
unknown's avatar
unknown committed
1787
	    (!test_all_bits(table->next->grant.privilege,
1788
			    INSERT_ACL | CREATE_ACL) &&
unknown's avatar
unknown committed
1789
	     check_grant(thd,INSERT_ACL | CREATE_ACL, &new_list)))
unknown's avatar
unknown committed
1790 1791 1792
	  goto error;
      }
    }
unknown's avatar
unknown committed
1793
    query_cache_invalidate3(thd, tables, 0);
1794 1795 1796
    if (end_active_trans(thd))
      res= -1;
    else if (mysql_rename_tables(thd,tables))
unknown's avatar
unknown committed
1797 1798
      res= -1;
    break;
unknown's avatar
unknown committed
1799
  }
unknown's avatar
unknown committed
1800 1801 1802 1803 1804 1805
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
    send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
    DBUG_VOID_RETURN;
#else
    {
unknown's avatar
unknown committed
1806
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
1807 1808 1809 1810 1811
	goto error;
      res = show_binlogs(thd);
      break;
    }
#endif    
unknown's avatar
unknown committed
1812
  case SQLCOM_SHOW_CREATE:
unknown's avatar
unknown committed
1813
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
1814
    send_error(&thd->net,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
unknown's avatar
unknown committed
1815 1816
    DBUG_VOID_RETURN;
#else
unknown's avatar
unknown committed
1817
    {
unknown's avatar
unknown committed
1818 1819 1820 1821
      if (check_db_used(thd, tables) ||
	  check_access(thd, SELECT_ACL | EXTRA_ACL, tables->db,
		       &tables->grant.privilege))
	goto error;
unknown's avatar
unknown committed
1822
      res = mysqld_show_create(thd, tables);
unknown's avatar
unknown committed
1823 1824
      break;
    }
unknown's avatar
unknown committed
1825
#endif
unknown's avatar
unknown committed
1826
  case SQLCOM_REPAIR:
1827 1828 1829 1830 1831 1832 1833
  {
    if (check_db_used(thd,tables) ||
	check_table_access(thd,SELECT_ACL | INSERT_ACL, tables))
      goto error; /* purecov: inspected */
    res = mysql_repair_table(thd, tables, &lex->check_opt);
    break;
  }
unknown's avatar
unknown committed
1834
  case SQLCOM_CHECK:
1835 1836 1837 1838 1839 1840 1841
  {
    if (check_db_used(thd,tables) ||
	check_table_access(thd, SELECT_ACL | EXTRA_ACL , tables))
      goto error; /* purecov: inspected */
    res = mysql_check_table(thd, tables, &lex->check_opt);
    break;
  }
unknown's avatar
unknown committed
1842 1843
  case SQLCOM_ANALYZE:
  {
unknown's avatar
unknown committed
1844 1845
    if (check_db_used(thd,tables) ||
	check_table_access(thd,SELECT_ACL | INSERT_ACL, tables))
unknown's avatar
unknown committed
1846
      goto error; /* purecov: inspected */
1847
    res = mysql_analyze_table(thd, tables, &lex->check_opt);
unknown's avatar
unknown committed
1848
    break;
unknown's avatar
unknown committed
1849
  }
1850

unknown's avatar
unknown committed
1851 1852 1853
  case SQLCOM_OPTIMIZE:
  {
    HA_CREATE_INFO create_info;
1854 1855
    if (check_db_used(thd,tables) ||
	check_table_access(thd,SELECT_ACL | INSERT_ACL, tables))
unknown's avatar
unknown committed
1856
      goto error; /* purecov: inspected */
1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870
    if (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC))
    {
      /* Use ALTER TABLE */
      lex->create_list.empty();
      lex->key_list.empty();
      lex->col_list.empty();
      lex->drop_list.empty();
      lex->alter_list.empty();
      bzero((char*) &create_info,sizeof(create_info));
      create_info.db_type=DB_TYPE_DEFAULT;
      create_info.row_type=ROW_TYPE_DEFAULT;
      res= mysql_alter_table(thd, NullS, NullS, &create_info,
			     tables, lex->create_list,
			     lex->key_list, lex->drop_list, lex->alter_list,
unknown's avatar
unknown committed
1871
                             (ORDER *) 0,
1872 1873 1874 1875
			     0,DUP_ERROR);
    }
    else
      res = mysql_optimize_table(thd, tables, &lex->check_opt);
unknown's avatar
unknown committed
1876 1877 1878
    break;
  }
  case SQLCOM_UPDATE:
unknown's avatar
unknown committed
1879 1880
    TABLE_LIST *table;
    if (check_db_used(thd,tables))
unknown's avatar
unknown committed
1881
      goto error;
unknown's avatar
unknown committed
1882 1883 1884 1885 1886
    for (table=tables ; table ; table=table->next)
    {
      if (check_access(thd,UPDATE_ACL,table->db,&table->grant.privilege))
	goto error;
    }
unknown's avatar
unknown committed
1887 1888
    if (grant_option && check_grant(thd,UPDATE_ACL,tables))
      goto error;
1889
    if (select_lex->item_list.elements != lex->value_list.elements)
unknown's avatar
unknown committed
1890 1891 1892 1893
    {
      send_error(&thd->net,ER_WRONG_VALUE_COUNT);
      DBUG_VOID_RETURN;
    }
1894 1895
    if (select_lex->table_list.elements == 1)
    {
unknown's avatar
unknown committed
1896 1897 1898 1899 1900 1901 1902
      res= mysql_update(thd,tables,
			select_lex->item_list,
			lex->value_list,
			select_lex->where,
			(ORDER *) select_lex->order_list.first,
			select_lex->select_limit,
			lex->duplicates);
1903
    }
unknown's avatar
unknown committed
1904
    else
1905
    {
unknown's avatar
unknown committed
1906 1907
      const char *msg= 0;
      lex->sql_command= SQLCOM_MULTI_UPDATE;
unknown's avatar
unknown committed
1908 1909 1910 1911 1912 1913
      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)
1914
      {
unknown's avatar
unknown committed
1915 1916 1917
	net_printf(&thd->net, ER_WRONG_USAGE, "UPDATE", msg);
	res= 1;
	break;
1918
      }
unknown's avatar
unknown committed
1919 1920 1921 1922 1923 1924
      res= mysql_multi_update(thd,tables,
			      &select_lex->item_list,
			      &lex->value_list,
			      select_lex->where,
			      select_lex->options,
			      lex->duplicates);
1925
    }
unknown's avatar
unknown committed
1926
    break;
unknown's avatar
unknown committed
1927 1928 1929 1930 1931 1932
  case SQLCOM_INSERT:
    if (check_access(thd,INSERT_ACL,tables->db,&tables->grant.privilege))
      goto error; /* purecov: inspected */
    if (grant_option && check_grant(thd,INSERT_ACL,tables))
      goto error;
    res = mysql_insert(thd,tables,lex->field_list,lex->many_values,
unknown's avatar
unknown committed
1933
		       lex->duplicates);
unknown's avatar
unknown committed
1934 1935
    break;
  case SQLCOM_REPLACE:
1936
    if (check_access(thd,INSERT_ACL | DELETE_ACL,
unknown's avatar
unknown committed
1937 1938
		     tables->db,&tables->grant.privilege))
      goto error; /* purecov: inspected */
1939
    if (grant_option && check_grant(thd,INSERT_ACL | DELETE_ACL,
unknown's avatar
unknown committed
1940 1941 1942 1943
				    tables))

      goto error;
    res = mysql_insert(thd,tables,lex->field_list,lex->many_values,
unknown's avatar
unknown committed
1944
		       DUP_REPLACE);
unknown's avatar
unknown committed
1945 1946 1947 1948
    break;
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
1949

unknown's avatar
unknown committed
1950 1951 1952 1953
    /*
      Check that we have modify privileges for the first table and
      select privileges for the rest
    */
1954
    {
unknown's avatar
unknown committed
1955
      ulong privilege= (lex->sql_command == SQLCOM_INSERT_SELECT ?
1956
			INSERT_ACL : INSERT_ACL | DELETE_ACL);
1957 1958 1959 1960 1961 1962 1963 1964 1965 1966
      TABLE_LIST *save_next=tables->next;
      tables->next=0;
      if (check_access(thd, privilege,
		       tables->db,&tables->grant.privilege) ||
	  (grant_option && check_grant(thd, privilege, tables)))
	goto error;
      tables->next=save_next;
      if ((res=check_table_access(thd, SELECT_ACL, save_next)))
	goto error;
    }
1967 1968
    /* Don't unlock tables until command is written to binary log */
    select_lex->options|= SELECT_NO_UNLOCK;
unknown's avatar
unknown committed
1969 1970

    select_result *result;
1971 1972 1973
    thd->offset_limit=select_lex->offset_limit;
    thd->select_limit=select_lex->select_limit+select_lex->offset_limit;
    if (thd->select_limit < select_lex->select_limit)
unknown's avatar
unknown committed
1974 1975
      thd->select_limit= HA_POS_ERROR;		// No limit

1976 1977 1978 1979 1980
    if (check_dup(tables->db, tables->real_name, tables->next))
    {
      /* Using same table for INSERT and SELECT */
      select_lex->options |= OPTION_BUFFER_RESULT;
    }
1981
    {
unknown's avatar
unknown committed
1982
      /* TODO: Delete the following loop when locks is set by sql_yacc */
1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993
      TABLE_LIST *table;
      for (table = tables->next ; table ; table=table->next)
	table->lock_type= lex->lock_option;
    }

    /* Skip first table, which is the table we are inserting in */
    lex->select_lex.table_list.first=
      (byte*) (((TABLE_LIST *) lex->select_lex.table_list.first)->next);
    if (!(res=open_and_lock_tables(thd, tables)))
    {
      if ((result=new select_insert(tables->table,&lex->field_list,
1994
				    lex->duplicates)))
1995 1996 1997 1998
	res=handle_select(thd,lex,result);
    }
    else
      res= -1;
unknown's avatar
unknown committed
1999 2000
    break;
  }
2001
  case SQLCOM_TRUNCATE:
2002 2003
    if (check_access(thd,DELETE_ACL,tables->db,&tables->grant.privilege))
      goto error; /* purecov: inspected */
unknown's avatar
unknown committed
2004 2005
    if (grant_option && check_grant(thd,DELETE_ACL,tables))
      goto error;
2006 2007 2008 2009 2010 2011
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
    if (thd->locked_tables || thd->active_transaction())
    {
unknown's avatar
unknown committed
2012
      send_error(&thd->net,ER_LOCK_OR_ACTIVE_TRANSACTION,NullS);
2013 2014 2015 2016
      goto error;
    }
    res=mysql_truncate(thd,tables);
    break;
unknown's avatar
unknown committed
2017
  case SQLCOM_DELETE:
unknown's avatar
unknown committed
2018 2019 2020 2021 2022 2023 2024
  {
    if (check_access(thd,DELETE_ACL,tables->db,&tables->grant.privilege))
      goto error; /* purecov: inspected */
    if (grant_option && check_grant(thd,DELETE_ACL,tables))
      goto error;
    // Set privilege for the WHERE clause
    tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
unknown's avatar
unknown committed
2025 2026
    res = mysql_delete(thd,tables, select_lex->where,
                       (ORDER*) select_lex->order_list.first,
unknown's avatar
unknown committed
2027
                       select_lex->select_limit, select_lex->options);
unknown's avatar
unknown committed
2028 2029
    break;
  }
2030
  case SQLCOM_DELETE_MULTI:
unknown's avatar
unknown committed
2031 2032 2033 2034 2035
  {
    TABLE_LIST *aux_tables=(TABLE_LIST *)thd->lex.auxilliary_table_list.first;
    TABLE_LIST *auxi;
    uint table_count=0;
    multi_delete *result;
unknown's avatar
unknown committed
2036

unknown's avatar
unknown committed
2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062
    /* sql_yacc guarantees that tables and aux_tables are not zero */
    if (check_db_used(thd, tables) || check_db_used(thd,aux_tables) ||
	check_table_access(thd,SELECT_ACL, tables) || 
	check_table_access(thd,DELETE_ACL, aux_tables))
      goto error;
    if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
    {		
      send_error(&thd->net,ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE);
      goto error;
    }
    for (auxi=(TABLE_LIST*) aux_tables ; auxi ; auxi=auxi->next)
    {
      table_count++;
      /* All tables in aux_tables must be found in FROM PART */
      TABLE_LIST *walk;
      for (walk=(TABLE_LIST*) tables ; walk ; walk=walk->next)
      {
	if (!strcmp(auxi->real_name,walk->real_name) &&
	    !strcmp(walk->db,auxi->db))
	  break;
      }
      if (!walk)
      {
	net_printf(&thd->net,ER_NONUNIQ_TABLE,auxi->real_name);
	goto error;
      }
unknown's avatar
unknown committed
2063
      walk->lock_type= auxi->lock_type;
unknown's avatar
unknown committed
2064 2065
      // Store address to table as we need it later
      auxi->table= my_reinterpret_cast(TABLE *) (walk);
2066 2067 2068
    }
    if (add_item_to_list(new Item_null()))
    {
unknown's avatar
unknown committed
2069
      res= -1;
2070
      break;
unknown's avatar
unknown committed
2071 2072 2073 2074 2075 2076 2077
    }
    tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
    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 */
    for (auxi=(TABLE_LIST*) aux_tables ; auxi ; auxi=auxi->next)
unknown's avatar
unknown committed
2078 2079
      auxi->table= (my_reinterpret_cast(TABLE_LIST*) (auxi->table))->table;

2080 2081
    if (!thd->fatal_error && (result= new multi_delete(thd,aux_tables,
						       table_count)))
unknown's avatar
unknown committed
2082 2083
    {
      res=mysql_select(thd,tables,select_lex->item_list,
2084
		       select_lex->where,
unknown's avatar
unknown committed
2085 2086 2087
		       (ORDER *)NULL,(ORDER *)NULL,(Item *)NULL,
		       (ORDER *)NULL,
		       select_lex->options | thd->options |
unknown's avatar
unknown committed
2088
		       SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK,
unknown's avatar
unknown committed
2089
		       result);
2090
      delete result;
unknown's avatar
unknown committed
2091 2092 2093 2094 2095 2096
    }
    else
      res= -1;					// Error is not sent
    close_thread_tables(thd);
    break;
  }
unknown's avatar
unknown committed
2097
  case SQLCOM_DROP_TABLE:
unknown's avatar
unknown committed
2098 2099 2100
  {
    if (check_table_access(thd,DROP_ACL,tables))
      goto error;				/* purecov: inspected */
2101 2102 2103 2104 2105 2106 2107 2108 2109 2110
    /*
      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.
      To not generate such irrelevant "table does not exist errors", we silently
      add IF EXISTS if TEMPORARY was used.
    */
    if (thd->slave_thread && lex->drop_temporary)
      lex->drop_if_exists= 1;
unknown's avatar
unknown committed
2111 2112 2113 2114 2115 2116
    if (end_active_trans(thd))
      res= -1;
    else
      res = mysql_rm_table(thd,tables,lex->drop_if_exists);
  }
  break;
unknown's avatar
unknown committed
2117 2118 2119 2120 2121 2122 2123
  case SQLCOM_DROP_INDEX:
    if (!tables->db)
      tables->db=thd->db;
    if (check_access(thd,INDEX_ACL,tables->db,&tables->grant.privilege))
      goto error;				/* purecov: inspected */
    if (grant_option && check_grant(thd,INDEX_ACL,tables))
      goto error;
2124 2125 2126 2127
    if (end_active_trans(thd))
      res= -1;
    else
      res = mysql_drop_index(thd, tables, lex->drop_list);
unknown's avatar
unknown committed
2128 2129
    break;
  case SQLCOM_SHOW_DATABASES:
2130
#if defined(DONT_ALLOW_SHOW_COMMANDS)
unknown's avatar
unknown committed
2131
    send_error(&thd->net,ER_NOT_ALLOWED_COMMAND);   /* purecov: inspected */
unknown's avatar
unknown committed
2132 2133 2134
    DBUG_VOID_RETURN;
#else
    if ((specialflag & SPECIAL_SKIP_SHOW_DB) &&
unknown's avatar
unknown committed
2135
	check_global_access(thd, SHOW_DB_ACL))
unknown's avatar
unknown committed
2136 2137 2138 2139 2140
      goto error;
    res= mysqld_show_dbs(thd, (lex->wild ? lex->wild->ptr() : NullS));
    break;
#endif
  case SQLCOM_SHOW_PROCESSLIST:
unknown's avatar
unknown committed
2141
    if (!thd->priv_user[0] && check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
2142 2143 2144 2145 2146
      break;
    mysqld_list_processes(thd,thd->master_access & PROCESS_ACL ? NullS :
			  thd->priv_user,lex->verbose);
    break;
  case SQLCOM_SHOW_STATUS:
2147
    res= mysqld_show(thd,(lex->wild ? lex->wild->ptr() : NullS),status_vars,
unknown's avatar
unknown committed
2148
		     OPT_GLOBAL);
unknown's avatar
unknown committed
2149 2150 2151
    break;
  case SQLCOM_SHOW_VARIABLES:
    res= mysqld_show(thd, (lex->wild ? lex->wild->ptr() : NullS),
unknown's avatar
unknown committed
2152
		     init_vars, lex->option_type);
unknown's avatar
unknown committed
2153
    break;
unknown's avatar
unknown committed
2154
  case SQLCOM_SHOW_LOGS:
unknown's avatar
unknown committed
2155 2156 2157 2158
  {
    res= mysqld_show_logs(thd);
    break;
  }
unknown's avatar
unknown committed
2159
  case SQLCOM_SHOW_TABLES:
2160
    /* FALL THROUGH */
unknown's avatar
unknown committed
2161 2162 2163 2164 2165
#ifdef DONT_ALLOW_SHOW_COMMANDS
    send_error(&thd->net,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
    DBUG_VOID_RETURN;
#else
    {
2166
      char *db=select_lex->db ? select_lex->db : thd->db;
unknown's avatar
unknown committed
2167 2168 2169 2170 2171 2172
      if (!db)
      {
	send_error(&thd->net,ER_NO_DB_ERROR);	/* purecov: inspected */
	goto error;				/* purecov: inspected */
      }
      remove_escape(db);				// Fix escaped '_'
2173
      if (check_db_name(db))
unknown's avatar
unknown committed
2174
      {
2175 2176
        net_printf(&thd->net,ER_WRONG_DB_NAME, db);
        goto error;
unknown's avatar
unknown committed
2177 2178 2179 2180
      }
      if (check_access(thd,SELECT_ACL,db,&thd->col_access))
	goto error;				/* purecov: inspected */
      /* grant is checked in mysqld_show_tables */
2181
      if (select_lex->options & SELECT_DESCRIBE)
2182
        res= mysqld_extend_show_tables(thd,db,
2183
				       (lex->wild ? lex->wild->ptr() : NullS));
unknown's avatar
unknown committed
2184 2185 2186 2187 2188 2189
      else
	res= mysqld_show_tables(thd,db,
				(lex->wild ? lex->wild->ptr() : NullS));
      break;
    }
#endif
2190 2191 2192
  case SQLCOM_SHOW_OPEN_TABLES:
    res= mysqld_show_open_tables(thd,(lex->wild ? lex->wild->ptr() : NullS));
    break;
unknown's avatar
unknown committed
2193 2194 2195 2196 2197 2198
  case SQLCOM_SHOW_FIELDS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
    send_error(&thd->net,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
    DBUG_VOID_RETURN;
#else
    {
2199 2200
      char *db=tables->db;
      if (!*db)
unknown's avatar
unknown committed
2201 2202 2203 2204 2205
      {
	send_error(&thd->net,ER_NO_DB_ERROR);	/* purecov: inspected */
	goto error;				/* purecov: inspected */
      }
      remove_escape(db);			// Fix escaped '_'
2206
      remove_escape(tables->real_name);
unknown's avatar
unknown committed
2207 2208 2209 2210 2211 2212
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,&thd->col_access))
	goto error;				/* purecov: inspected */
      tables->grant.privilege=thd->col_access;
      if (grant_option && check_grant(thd,SELECT_ACL,tables,2))
	goto error;
      res= mysqld_show_fields(thd,tables,
unknown's avatar
unknown committed
2213 2214
			      (lex->wild ? lex->wild->ptr() : NullS),
			      lex->verbose);
unknown's avatar
unknown committed
2215 2216 2217 2218 2219 2220 2221 2222 2223
      break;
    }
#endif
  case SQLCOM_SHOW_KEYS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
    send_error(&thd->net,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
    DBUG_VOID_RETURN;
#else
    {
2224
      char *db=tables->db;
unknown's avatar
unknown committed
2225 2226 2227 2228 2229 2230
      if (!db)
      {
	send_error(&thd->net,ER_NO_DB_ERROR);	/* purecov: inspected */
	goto error;				/* purecov: inspected */
      }
      remove_escape(db);			// Fix escaped '_'
2231
      remove_escape(tables->real_name);
unknown's avatar
unknown committed
2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243
      if (!tables->db)
	tables->db=thd->db;
      if (check_access(thd,SELECT_ACL,db,&thd->col_access))
	goto error; /* purecov: inspected */
      tables->grant.privilege=thd->col_access;
      if (grant_option && check_grant(thd,SELECT_ACL,tables,2))
	goto error;
      res= mysqld_show_keys(thd,tables);
      break;
    }
#endif
  case SQLCOM_CHANGE_DB:
2244
    mysql_change_db(thd,select_lex->db);
unknown's avatar
unknown committed
2245 2246 2247 2248 2249
    break;
  case SQLCOM_LOAD:
  {
    uint privilege= (lex->duplicates == DUP_REPLACE ?
		     INSERT_ACL | UPDATE_ACL | DELETE_ACL : INSERT_ACL);
2250 2251

    if (!lex->local_file)
unknown's avatar
unknown committed
2252 2253 2254 2255 2256 2257
    {
      if (check_access(thd,privilege | FILE_ACL,tables->db))
	goto error;
    }
    else
    {
2258
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
unknown's avatar
unknown committed
2259
	  ! opt_local_infile)
2260 2261 2262 2263
      {
	send_error(&thd->net,ER_NOT_ALLOWED_COMMAND);
	goto error;
      }
unknown's avatar
unknown committed
2264
      if (check_access(thd,privilege,tables->db,&tables->grant.privilege) ||
2265
	  grant_option && check_grant(thd,privilege,tables))
unknown's avatar
unknown committed
2266 2267 2268 2269 2270 2271 2272
	goto error;
    }
    res=mysql_load(thd, lex->exchange, tables, lex->field_list,
		   lex->duplicates, (bool) lex->local_file, lex->lock_option);
    break;
  }
  case SQLCOM_SET_OPTION:
2273
    if (!(res=sql_set_variables(thd, &lex->var_list)))
unknown's avatar
unknown committed
2274
      send_ok(&thd->net);
unknown's avatar
unknown committed
2275 2276
    break;
  case SQLCOM_UNLOCK_TABLES:
unknown's avatar
unknown committed
2277
    unlock_locked_tables(thd);
unknown's avatar
unknown committed
2278 2279
    if (thd->options & OPTION_TABLE_LOCK)
    {
unknown's avatar
unknown committed
2280
      end_active_trans(thd);
unknown's avatar
unknown committed
2281
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
2282 2283
    }
    if (thd->global_read_lock)
2284
      unlock_global_read_lock(thd);
unknown's avatar
unknown committed
2285 2286 2287
    send_ok(&thd->net);
    break;
  case SQLCOM_LOCK_TABLES:
unknown's avatar
unknown committed
2288
    unlock_locked_tables(thd);
2289
    if (check_db_used(thd,tables) || end_active_trans(thd))
unknown's avatar
unknown committed
2290
      goto error;
unknown's avatar
unknown committed
2291
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, tables))
2292
      goto error;
unknown's avatar
unknown committed
2293
    thd->in_lock_tables=1;
unknown's avatar
unknown committed
2294
    thd->options|= OPTION_TABLE_LOCK;
unknown's avatar
unknown committed
2295 2296 2297 2298 2299 2300
    if (!(res=open_and_lock_tables(thd,tables)))
    {
      thd->locked_tables=thd->lock;
      thd->lock=0;
      send_ok(&thd->net);
    }
unknown's avatar
unknown committed
2301 2302
    else
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
2303 2304 2305
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
2306
  {
unknown's avatar
unknown committed
2307
    if (!strip_sp(lex->name) || check_db_name(lex->name))
unknown's avatar
unknown committed
2308
    {
2309
      net_printf(&thd->net,ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
2310 2311
      break;
    }
2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323
    /*
      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.
    */
    if (thd->slave_thread && 
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
      break;

2324 2325
    if (check_access(thd,CREATE_ACL,lex->name,0,1))
      break;
unknown's avatar
unknown committed
2326
    res=mysql_create_db(thd,lex->name,lex->create_info.options,0);
2327 2328
    break;
  }
unknown's avatar
unknown committed
2329
  case SQLCOM_DROP_DB:
2330
  {
unknown's avatar
unknown committed
2331
    if (!strip_sp(lex->name) || check_db_name(lex->name))
unknown's avatar
unknown committed
2332
    {
2333
      net_printf(&thd->net,ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
2334 2335
      break;
    }
2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346
    /*
      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.
    */
    if (thd->slave_thread && 
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
      break;
2347
    if (check_access(thd,DROP_ACL,lex->name,0,1))
2348
      break;
2349 2350
    if (thd->locked_tables || thd->active_transaction())
    {
unknown's avatar
unknown committed
2351
      send_error(&thd->net,ER_LOCK_OR_ACTIVE_TRANSACTION);
2352 2353
      goto error;
    }
unknown's avatar
unknown committed
2354
    res=mysql_rm_db(thd,lex->name,lex->drop_if_exists,0);
2355 2356
    break;
  }
unknown's avatar
unknown committed
2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376
  case SQLCOM_CREATE_FUNCTION:
    if (check_access(thd,INSERT_ACL,"mysql",0,1))
      break;
#ifdef HAVE_DLOPEN
    if (!(res = mysql_create_function(thd,&lex->udf)))
      send_ok(&thd->net);
#else
    res= -1;
#endif
    break;
  case SQLCOM_DROP_FUNCTION:
    if (check_access(thd,DELETE_ACL,"mysql",0,1))
      break;
#ifdef HAVE_DLOPEN
    if (!(res = mysql_drop_function(thd,lex->udf.name)))
      send_ok(&thd->net);
#else
    res= -1;
#endif
    break;
2377 2378 2379 2380 2381 2382 2383 2384 2385
  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,
		     tables ? 0 : 1))
      goto error;

unknown's avatar
unknown committed
2386 2387 2388 2389
    /*
      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
    */
2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414

    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 &&
	     my_strcasecmp(user->host.str, thd->host_or_ip)))
	{
	  if (check_access(thd, UPDATE_ACL, "mysql",0,1))
	    goto error;
	  break;			// We are allowed to do changes
	}
      }
    }
    if (tables)
    {
      if (grant_option && check_grant(thd,
				      (lex->grant | lex->grant_tot_col |
				       GRANT_ACL),
				      tables))
	goto error;
unknown's avatar
unknown committed
2415 2416 2417
      if (!(res = mysql_table_grant(thd,tables,lex->users_list, lex->columns,
				    lex->grant,
				    lex->sql_command == SQLCOM_REVOKE)))
2418
      {
2419
	mysql_update_log.write(thd, thd->query, thd->query_length);
2420 2421
	if (mysql_bin_log.is_open())
	{
2422
	  Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
2423 2424 2425 2426 2427 2428 2429 2430
	  mysql_bin_log.write(&qinfo);
	}
      }
    }
    else
    {
      if (lex->columns.elements)
      {
unknown's avatar
unknown committed
2431
	send_error(&thd->net,ER_ILLEGAL_GRANT_FOR_TABLE);
2432 2433 2434 2435 2436 2437 2438
	res=1;
      }
      else
	res = mysql_grant(thd, select_lex->db, lex->users_list, lex->grant,
			  lex->sql_command == SQLCOM_REVOKE);
      if (!res)
      {
2439
	mysql_update_log.write(thd, thd->query, thd->query_length);
2440 2441
	if (mysql_bin_log.is_open())
	{
2442
	  Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
2443 2444
	  mysql_bin_log.write(&qinfo);
	}
2445
	if (mqh_used && lex->sql_command == SQLCOM_GRANT)
2446
	{
unknown's avatar
unknown committed
2447 2448 2449
	  List_iterator <LEX_USER> str_list(lex->users_list);
	  LEX_USER *user;
	  while ((user=str_list++))
2450
	    reset_mqh(thd,user);
2451
	}
2452 2453 2454 2455
      }
    }
    break;
  }
unknown's avatar
unknown committed
2456
  case SQLCOM_FLUSH:
unknown's avatar
unknown committed
2457
  case SQLCOM_RESET:
unknown's avatar
unknown committed
2458
    if (check_global_access(thd,RELOAD_ACL) || check_db_used(thd, tables))
unknown's avatar
unknown committed
2459
      goto error;
2460 2461
    /* error sending is deferred to reload_acl_and_cache */
    reload_acl_and_cache(thd, lex->type, tables) ;
unknown's avatar
unknown committed
2462 2463 2464 2465 2466 2467
    break;
  case SQLCOM_KILL:
    kill_one_thread(thd,lex->thread_id);
    break;
  case SQLCOM_SHOW_GRANTS:
    res=0;
2468 2469
    if ((thd->priv_user &&
	 !strcmp(thd->priv_user,lex->grant_user->user.str)) ||
2470
	!check_access(thd, SELECT_ACL, "mysql",0,1))
unknown's avatar
unknown committed
2471 2472 2473 2474
    {
      res = mysql_show_grants(thd,lex->grant_user);
    }
    break;
2475
  case SQLCOM_HA_OPEN:
2476 2477
    if (check_db_used(thd,tables) ||
	check_table_access(thd,SELECT_ACL, tables))
2478 2479 2480 2481 2482 2483 2484 2485 2486
      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:
2487 2488 2489 2490 2491
    /*
      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
2492
    if (check_db_used(thd,tables))
2493
      goto error;
unknown's avatar
unknown committed
2494
    res = mysql_ha_read(thd, tables, lex->ha_read_mode, lex->backup_dir,
2495 2496
			lex->insert_list, lex->ha_rkey_mode, select_lex->where,
			select_lex->select_limit, select_lex->offset_limit);
2497 2498
    break;

unknown's avatar
unknown committed
2499
  case SQLCOM_BEGIN:
unknown's avatar
unknown committed
2500 2501 2502 2503 2504 2505
    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
2506 2507 2508 2509 2510 2511
    if (end_active_trans(thd))
    {
      res= -1;
    }
    else
    {
2512
      thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
unknown's avatar
unknown committed
2513 2514 2515 2516
		     OPTION_BEGIN);
      thd->server_status|= SERVER_STATUS_IN_TRANS;
      send_ok(&thd->net);
    }
unknown's avatar
unknown committed
2517 2518
    break;
  case SQLCOM_COMMIT:
2519 2520 2521 2522 2523
    /*
      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
2524
  {
2525
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
2526 2527
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
    if (!ha_commit(thd))
unknown's avatar
unknown committed
2528
    {
unknown's avatar
unknown committed
2529
      send_ok(&thd->net);
unknown's avatar
unknown committed
2530
    }
unknown's avatar
unknown committed
2531 2532 2533
    else
      res= -1;
    break;
unknown's avatar
unknown committed
2534
  }
unknown's avatar
unknown committed
2535 2536 2537
  case SQLCOM_ROLLBACK:
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
    if (!ha_rollback(thd))
2538 2539 2540 2541 2542 2543
    {
      if (thd->options & OPTION_STATUS_NO_TRANS_UPDATE)
	send_warning(&thd->net,ER_WARNING_NOT_COMPLETE_ROLLBACK,0);
      else
	send_ok(&thd->net);
    }
unknown's avatar
unknown committed
2544 2545
    else
      res= -1;
2546
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
2547
    break;
unknown's avatar
unknown committed
2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
    if (!ha_rollback_to_savepoint(thd, lex->savepoint_name))
    {
      if (thd->options & OPTION_STATUS_NO_TRANS_UPDATE)
	send_warning(&thd->net,ER_WARNING_NOT_COMPLETE_ROLLBACK,0);
      else
	send_ok(&thd->net);
    }
    else
      res= -1;
    break;
2559
  case SQLCOM_SAVEPOINT:
unknown's avatar
unknown committed
2560 2561 2562 2563
    if (!ha_savepoint(thd, lex->savepoint_name))
      send_ok(&thd->net);
    else
      res= -1;
2564
    break;
unknown's avatar
unknown committed
2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578
  default:					/* Impossible */
    send_ok(&thd->net);
    break;
  }
  thd->proc_info="query end";			// QQ
  if (res < 0)
    send_error(&thd->net,thd->killed ? ER_SERVER_SHUTDOWN : 0);

error:
  DBUG_VOID_RETURN;
}


/****************************************************************************
unknown's avatar
unknown committed
2579
  Get the user (global) and database privileges for all used tables
unknown's avatar
unknown committed
2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592

  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
2593 2594
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
unknown's avatar
unknown committed
2595 2596 2597
****************************************************************************/

bool
unknown's avatar
unknown committed
2598
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
2599
	     bool dont_check_global_grants, bool no_errors)
unknown's avatar
unknown committed
2600
{
unknown's avatar
unknown committed
2601 2602 2603 2604
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("want_access: %lu  master_access: %lu", want_access,
		      thd->master_access));
  ulong db_access,dummy;
unknown's avatar
unknown committed
2605 2606 2607 2608 2609
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

2610
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
unknown's avatar
unknown committed
2611
  {
2612 2613
    if (!no_errors)
      send_error(&thd->net,ER_NO_DB_ERROR);	/* purecov: tested */
unknown's avatar
unknown committed
2614
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
2615 2616 2617 2618
  }

  if ((thd->master_access & want_access) == want_access)
  {
2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
    /*
      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))))
      db_access=acl_get(thd->host, thd->ip, (char*) &thd->remote.sin_addr,
			thd->priv_user, db); /* purecov: inspected */
    *save_priv=thd->master_access | db_access;
unknown's avatar
unknown committed
2630
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
2631
  }
2632
  if (((want_access & ~thd->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
2633
      ! db && dont_check_global_grants)
unknown's avatar
unknown committed
2634
  {						// We can never grant this
2635 2636 2637
    if (!no_errors)
      net_printf(&thd->net,ER_ACCESS_DENIED_ERROR,
		 thd->priv_user,
2638
		 thd->priv_host,
2639
		 thd->password ? ER(ER_YES) : ER(ER_NO));/* purecov: tested */
unknown's avatar
unknown committed
2640
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
2641 2642 2643
  }

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

unknown's avatar
unknown committed
2646 2647 2648 2649 2650
  if (db && (!thd->db || strcmp(db,thd->db)))
    db_access=acl_get(thd->host, thd->ip, (char*) &thd->remote.sin_addr,
		      thd->priv_user, db); /* purecov: inspected */
  else
    db_access=thd->db_access;
2651 2652
  // Remove SHOW attribute and access rights we already have
  want_access &= ~(thd->master_access | EXTRA_ACL);
unknown's avatar
unknown committed
2653
  db_access= ((*save_priv=(db_access | thd->master_access)) & want_access);
2654 2655

  /* grant_option is set if there exists a single table or column grant */
unknown's avatar
unknown committed
2656
  if (db_access == want_access ||
2657 2658
      ((grant_option && !dont_check_global_grants) &&
       !(want_access & ~TABLE_ACLS)))
unknown's avatar
unknown committed
2659
    DBUG_RETURN(FALSE);				/* Ok */
2660 2661 2662
  if (!no_errors)
    net_printf(&thd->net,ER_DBACCESS_DENIED_ERROR,
	       thd->priv_user,
2663
	       thd->priv_host,
2664
	       db ? db : thd->db ? thd->db : "unknown"); /* purecov: tested */
unknown's avatar
unknown committed
2665
  DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
2666 2667 2668
}


2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686
/*
  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
2687 2688

bool check_global_access(THD *thd, ulong want_access)
unknown's avatar
unknown committed
2689
{
unknown's avatar
unknown committed
2690
  char command[128];
2691
  if ((thd->master_access & want_access))
unknown's avatar
unknown committed
2692 2693 2694 2695 2696
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
  net_printf(&thd->net,ER_SPECIFIC_ACCESS_DENIED_ERROR,
	     command);
  return 1;
unknown's avatar
unknown committed
2697 2698 2699
}


unknown's avatar
unknown committed
2700
/*
unknown's avatar
unknown committed
2701 2702
  Check the privilege for all used tables.  Table privileges are cached
  in the table list for GRANT checking
unknown's avatar
unknown committed
2703 2704
*/

2705
bool
unknown's avatar
unknown committed
2706
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
2707
		   bool no_errors)
unknown's avatar
unknown committed
2708
{
unknown's avatar
unknown committed
2709 2710
  uint found=0;
  ulong found_access=0;
unknown's avatar
unknown committed
2711 2712 2713
  TABLE_LIST *org_tables=tables;
  for (; tables ; tables=tables->next)
  {
unknown's avatar
unknown committed
2714 2715
    if ((thd->master_access & want_access) == (want_access & ~EXTRA_ACL) &&
	thd->db)
unknown's avatar
unknown committed
2716
      tables->grant.privilege= want_access;
unknown's avatar
unknown committed
2717
    else if (tables->db && tables->db == thd->db)
unknown's avatar
unknown committed
2718 2719 2720 2721 2722
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
2723 2724
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
			 0, no_errors))
unknown's avatar
unknown committed
2725 2726
	  return TRUE;				// Access denied
	found_access=tables->grant.privilege;
unknown's avatar
unknown committed
2727
	found=1;
unknown's avatar
unknown committed
2728 2729
      }
    }
2730
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
2731
			  0, no_errors))
2732
      return TRUE;
unknown's avatar
unknown committed
2733 2734
  }
  if (grant_option)
2735
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
2736
		       test(want_access & EXTRA_ACL), no_errors);
unknown's avatar
unknown committed
2737 2738 2739 2740
  return FALSE;
}


unknown's avatar
unknown committed
2741
static bool check_db_used(THD *thd,TABLE_LIST *tables)
unknown's avatar
unknown committed
2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757
{
  for (; tables ; tables=tables->next)
  {
    if (!tables->db)
    {
      if (!(tables->db=thd->db))
      {
	send_error(&thd->net,ER_NO_DB_ERROR);	/* purecov: tested */
	return TRUE;				/* purecov: tested */
      }
    }
  }
  return FALSE;
}


2758 2759
static bool check_merge_table_access(THD *thd, char *db,
				     TABLE_LIST *table_list)
2760 2761 2762 2763
{
  int error=0;
  if (table_list)
  {
2764
    /* Check that all tables use the current database */
2765 2766
    TABLE_LIST *tmp;
    for (tmp=table_list; tmp ; tmp=tmp->next)
2767 2768 2769
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
unknown's avatar
unknown committed
2770
      else if (strcmp(tmp->db,db))
2771 2772 2773 2774 2775
      {
	send_error(&thd->net,ER_UNION_TABLES_IN_DIFFERENT_DIR);
	return 1;
      }
    }
2776 2777 2778 2779 2780 2781 2782
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
			     table_list);
  }
  return error;
}


unknown's avatar
unknown committed
2783 2784 2785 2786 2787 2788 2789 2790 2791 2792
/****************************************************************************
	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

2793
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806
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));
    thd->fatal_error=1;
    return 1;
  }
  return 0;
}
2807
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841

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

bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, int *yystacksize)
{
  LEX	*lex=current_lex;
  int  old_info=0;
  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;
}


/****************************************************************************
2842
	Initialize global thd variables needed for query
unknown's avatar
unknown committed
2843 2844 2845 2846 2847 2848
****************************************************************************/

static void
mysql_init_query(THD *thd)
{
  DBUG_ENTER("mysql_init_query");
2849
  thd->lex.select_lex.item_list.empty();
unknown's avatar
unknown committed
2850
  thd->lex.value_list.empty();
2851
  thd->lex.select_lex.table_list.elements=0;
unknown's avatar
unknown committed
2852
  thd->free_list=0;  thd->lex.union_option=0;
2853 2854 2855
  thd->lex.select = &thd->lex.select_lex;
  thd->lex.select_lex.table_list.first=0;
  thd->lex.select_lex.table_list.next= (byte**) &thd->lex.select_lex.table_list.first;
unknown's avatar
unknown committed
2856
  thd->lex.select_lex.next=0;
2857
  thd->lex.olap=0;
2858
  thd->lex.select->olap= UNSPECIFIED_OLAP_TYPE;
unknown's avatar
unknown committed
2859 2860
  thd->fatal_error=0;				// Safety
  thd->last_insert_id_used=thd->query_start_used=thd->insert_id_used=0;
unknown's avatar
unknown committed
2861
  thd->rand_used=0;
2862
  thd->sent_row_count=thd->examined_row_count=0;
2863
  thd->safe_to_cache_query=1;
unknown's avatar
unknown committed
2864 2865 2866
  DBUG_VOID_RETURN;
}

2867 2868 2869
void
mysql_init_select(LEX *lex)
{
2870 2871
  SELECT_LEX *select_lex = lex->select;
  select_lex->where=select_lex->having=0;
unknown's avatar
unknown committed
2872
  select_lex->select_limit= lex->thd->variables.select_limit;
unknown's avatar
unknown committed
2873
  select_lex->offset_limit=0;
unknown's avatar
unknown committed
2874 2875
  select_lex->options=0;
  select_lex->linkage=UNSPECIFIED_TYPE;
2876
  select_lex->olap=   UNSPECIFIED_OLAP_TYPE;
2877
  lex->exchange = 0;
2878
  lex->proc_list.first=0;
unknown's avatar
unknown committed
2879 2880
  select_lex->order_list.empty();
  select_lex->group_list.empty();
2881
  select_lex->next = (SELECT_LEX *)NULL; 
2882 2883
}

2884

unknown's avatar
unknown committed
2885
bool
2886 2887
mysql_new_select(LEX *lex)
{
2888
  SELECT_LEX *select_lex = (SELECT_LEX *) lex->thd->calloc(sizeof(SELECT_LEX));
unknown's avatar
unknown committed
2889 2890
  if (!select_lex)
    return 1;
2891
  lex->select->next=select_lex; 
2892
  lex->select=select_lex;
unknown's avatar
unknown committed
2893
  select_lex->table_list.next= (byte**) &select_lex->table_list.first;
unknown's avatar
unknown committed
2894 2895 2896 2897 2898 2899 2900
  select_lex->item_list.empty();
  select_lex->when_list.empty(); 
  select_lex->expr_list.empty();
  select_lex->interval_list.empty(); 
  select_lex->use_index.empty();
  select_lex->ftfunc_list.empty();
  return 0;
2901
}
unknown's avatar
unknown committed
2902

2903

unknown's avatar
unknown committed
2904 2905 2906 2907
void mysql_init_multi_delete(LEX *lex)
{
  lex->sql_command =  SQLCOM_DELETE_MULTI;
  mysql_init_select(lex);
2908
  lex->select->select_limit=lex->thd->select_limit=HA_POS_ERROR;
2909
  lex->select->table_list.save_and_clear(&lex->auxilliary_table_list);
unknown's avatar
unknown committed
2910
}
unknown's avatar
unknown committed
2911

2912

unknown's avatar
unknown committed
2913 2914 2915 2916 2917 2918 2919
void
mysql_parse(THD *thd,char *inBuf,uint length)
{
  DBUG_ENTER("mysql_parse");

  mysql_init_query(thd);
  thd->query_length = length;
unknown's avatar
unknown committed
2920
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
unknown's avatar
unknown committed
2921 2922 2923 2924
  {
    LEX *lex=lex_start(thd, (uchar*) inBuf, length);
    if (!yyparse() && ! thd->fatal_error)
    {
2925 2926
      if (mqh_used && thd->user_connect &&
	  check_mqh(thd, thd->lex.sql_command))
2927 2928 2929 2930 2931 2932 2933 2934
      {
	thd->net.error = 0;
      }
      else
      {
	mysql_execute_command();
	query_cache_end_of_result(&thd->net);
      }
unknown's avatar
unknown committed
2935 2936
    }
    else
2937 2938 2939
    {
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
			 thd->fatal_error));
unknown's avatar
unknown committed
2940
      query_cache_abort(&thd->net);
2941
    }
unknown's avatar
unknown committed
2942 2943 2944 2945
    thd->proc_info="freeing items";
    free_items(thd);  /* Free strings used by items */
    lex_end(lex);
  }
unknown's avatar
unknown committed
2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985
  DBUG_VOID_RETURN;
}


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

bool add_field_to_list(char *field_name, enum_field_types type,
		       char *length, char *decimals,
		       uint type_modifier, Item *default_value,char *change,
		       TYPELIB *interval)
{
  register create_field *new_field;
  THD	*thd=current_thd;
  LEX  *lex= &thd->lex;
  uint allowed_type_modifier=0;
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
    net_printf(&thd->net, ER_TOO_LONG_IDENT, field_name); /* purecov: inspected */
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
    lex->key_list.push_back(new Key(Key::PRIMARY,NullS,
				    lex->col_list));
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
    lex->key_list.push_back(new Key(Key::UNIQUE,NullS,
				    lex->col_list));
    lex->col_list.empty();
  }

2986
  if (default_value)
unknown's avatar
unknown committed
2987
  {
2988
    if (default_value->type() == Item::NULL_ITEM)
unknown's avatar
unknown committed
2989
    {
2990 2991 2992 2993 2994 2995 2996 2997
      default_value=0;
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
	net_printf(&thd->net,ER_INVALID_DEFAULT,field_name);
	DBUG_RETURN(1);
      }
    }
2998
#ifdef MYSQL41000
2999 3000 3001
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
      net_printf(&thd->net, ER_INVALID_DEFAULT, field_name);
unknown's avatar
unknown committed
3002 3003
      DBUG_RETURN(1);
    }
3004
#endif
unknown's avatar
unknown committed
3005 3006 3007 3008 3009
  }
  if (!(new_field=new create_field()))
    DBUG_RETURN(1);
  new_field->field=0;
  new_field->field_name=field_name;
3010
#ifdef MYSQL41000
3011
  new_field->def= default_value;
3012 3013 3014
#else
  new_field->def= (type_modifier & AUTO_INCREMENT_FLAG ? 0 : default_value);
#endif
unknown's avatar
unknown committed
3015 3016 3017 3018 3019 3020 3021 3022 3023 3024
  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;
3025 3026
  if (length && !(new_field->length= (uint) atoi(length)))
    length=0; /* purecov: inspected */
unknown's avatar
unknown committed
3027 3028 3029
  uint sign_len=type_modifier & UNSIGNED_FLAG ? 0 : 1;

  if (new_field->length && new_field->decimals &&
3030
      new_field->length < new_field->decimals+1 &&
unknown's avatar
unknown committed
3031
      new_field->decimals != NOT_FIXED_DEC)
3032
    new_field->length=new_field->decimals+1; /* purecov: inspected */
unknown's avatar
unknown committed
3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057

  switch (type) {
  case FIELD_TYPE_TINY:
    if (!length) new_field->length=3+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_SHORT:
    if (!length) new_field->length=5+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_INT24:
    if (!length) new_field->length=8+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONG:
    if (!length) new_field->length=10+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONGLONG:
    if (!length) new_field->length=20;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_STRING:
  case FIELD_TYPE_VAR_STRING:
  case FIELD_TYPE_NULL:
unknown's avatar
unknown committed
3058
  case FIELD_TYPE_GEOMETRY:
unknown's avatar
unknown committed
3059 3060 3061
    break;
  case FIELD_TYPE_DECIMAL:
    if (!length)
3062 3063 3064 3065 3066 3067 3068
      new_field->length= 10;			// Default length for DECIMAL
    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
3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162
    break;
  case FIELD_TYPE_BLOB:
  case FIELD_TYPE_TINY_BLOB:
  case FIELD_TYPE_LONG_BLOB:
  case FIELD_TYPE_MEDIUM_BLOB:
    if (default_value)				// Allow empty as default value
    {
      String str,*res;
      res=default_value->val_str(&str);
      if (res->length())
      {
	net_printf(&thd->net,ER_BLOB_CANT_HAVE_DEFAULT,field_name); /* purecov: inspected */
	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)
      {
	net_printf(&thd->net,ER_WRONG_FIELD_SPEC,field_name);
	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
    else
    {
      new_field->length=((new_field->length+1)/2)*2; /* purecov: inspected */
      new_field->length= min(new_field->length,14); /* purecov: inspected */
    }
    new_field->flags|= ZEROFILL_FLAG | UNSIGNED_FLAG | NOT_NULL_FLAG;
    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)
      {
	net_printf(&thd->net,ER_TOO_BIG_SET,field_name); /* purecov: inspected */
	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
3163 3164 3165
      {
	new_field->length+=(uint) strip_sp((char*) *pos)+1;
      }
unknown's avatar
unknown committed
3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185
      new_field->length--;
      set_if_smaller(new_field->length,MAX_FIELD_WIDTH-1);
      if (default_value)
      {
	thd->cuted_fields=0;
	String str,*res;
	res=default_value->val_str(&str);
	(void) find_set(interval,res->ptr(),res->length());
	if (thd->cuted_fields)
	{
	  net_printf(&thd->net,ER_INVALID_DEFAULT,field_name);
	  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
3186
      new_field->length=(uint) strip_sp((char*) interval->type_names[0]);
unknown's avatar
unknown committed
3187 3188
      for (const char **pos=interval->type_names+1; *pos ; pos++)
      {
unknown's avatar
unknown committed
3189
	uint length=(uint) strip_sp((char*) *pos);
unknown's avatar
unknown committed
3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208
	set_if_bigger(new_field->length,length);
      }
      set_if_smaller(new_field->length,MAX_FIELD_WIDTH-1);
      if (default_value)
      {
	String str,*res;
	res=default_value->val_str(&str);
	if (!find_enum(interval,res->ptr(),res->length()))
	{
	  net_printf(&thd->net,ER_INVALID_DEFAULT,field_name);
	  DBUG_RETURN(1);
	}
      }
      break;
    }
  }

  if (new_field->length >= MAX_FIELD_WIDTH ||
      (!new_field->length && !(new_field->flags & BLOB_FLAG) &&
unknown's avatar
unknown committed
3209
       type != FIELD_TYPE_STRING && type != FIELD_TYPE_VAR_STRING))
unknown's avatar
unknown committed
3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239
  {
    net_printf(&thd->net,ER_TOO_BIG_FIELDLENGTH,field_name,
	       MAX_FIELD_WIDTH-1);		/* purecov: inspected */
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  type_modifier&= AUTO_INCREMENT_FLAG;
  if ((~allowed_type_modifier) & type_modifier)
  {
    net_printf(&thd->net,ER_WRONG_FIELD_SPEC,field_name);
    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
3240
add_proc_to_list(THD* thd, Item *item)
unknown's avatar
unknown committed
3241 3242 3243 3244 3245 3246 3247 3248 3249 3250
{
  ORDER *order;
  Item	**item_ptr;

  if (!(order = (ORDER *) sql_alloc(sizeof(ORDER)+sizeof(Item*))))
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
unknown's avatar
unknown committed
3251
  thd->lex.proc_list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
3252 3253 3254 3255 3256 3257 3258 3259
  return 0;
}


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

static void remove_escape(char *name)
{
3260 3261
  if (!*name)					// For empty DB names
    return;
unknown's avatar
unknown committed
3262 3263
  char *to;
#ifdef USE_MB
unknown's avatar
unknown committed
3264
  char *strend=name+(uint) strlen(name);
unknown's avatar
unknown committed
3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
/*    if ((l = ismbchar(name, name+MBMAXLEN))) { Wei He: I think it's wrong */
    if (use_mb(default_charset_info) &&
        (l = my_ismbchar(default_charset_info, name, strend)))
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
unknown's avatar
unknown committed
3281
      name++;					// Skip '\\'
unknown's avatar
unknown committed
3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304
    *to++= *name;
  }
  *to=0;
}

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


bool add_to_list(SQL_LIST &list,Item *item,bool asc)
{
  ORDER *order;
  Item	**item_ptr;
  DBUG_ENTER("add_to_list");
  if (!(order = (ORDER *) sql_alloc(sizeof(ORDER)+sizeof(Item*))))
    DBUG_RETURN(1);
  item_ptr = (Item**) (order+1);
  *item_ptr=item;
  order->item= item_ptr;
  order->asc = asc;
  order->free_me=0;
  order->used=0;
unknown's avatar
unknown committed
3305
  list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
3306 3307 3308 3309
  DBUG_RETURN(0);
}


3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328
/*
  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
3329
TABLE_LIST *add_table_to_list(Table_ident *table, LEX_STRING *alias,
3330 3331
			      ulong table_options,
			      thr_lock_type lock_type,
unknown's avatar
unknown committed
3332
			      List<String> *use_index,
3333
			      List<String> *ignore_index)
unknown's avatar
unknown committed
3334 3335 3336 3337 3338 3339 3340 3341 3342
{
  register TABLE_LIST *ptr;
  THD	*thd=current_thd;
  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
3343
  if (check_table_name(table->table.str,table->table.length) ||
3344
      table->db.str && check_db_name(table->db.str))
unknown's avatar
unknown committed
3345 3346 3347 3348 3349 3350
  {
    net_printf(&thd->net,ER_WRONG_TABLE_NAME,table->table.str);
    DBUG_RETURN(0);
  }

  if (!alias)					/* Alias is case sensitive */
3351
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
unknown's avatar
unknown committed
3352
      DBUG_RETURN(0);
unknown's avatar
unknown committed
3353
    
unknown's avatar
unknown committed
3354
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
3355
    DBUG_RETURN(0);				/* purecov: inspected */
3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371
  if (table->db.str) 
  {
    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
  {
    ptr->db= (char*) "";
    ptr->db_length= 0;
  }
    
3372
  ptr->alias= alias_str;
unknown's avatar
unknown committed
3373 3374 3375
  if (lower_case_table_names)
    casedn_str(table->table.str);
  ptr->real_name=table->table.str;
3376
  ptr->real_name_length=table->table.length;
3377 3378 3379
  ptr->lock_type= lock_type;
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
unknown's avatar
unknown committed
3380
  if (use_index)
unknown's avatar
unknown committed
3381
    ptr->use_index=(List<String> *) thd->memdup((gptr) use_index,
unknown's avatar
unknown committed
3382 3383
					       sizeof(*use_index));
  if (ignore_index)
unknown's avatar
unknown committed
3384 3385
    ptr->ignore_index=(List<String> *) thd->memdup((gptr) ignore_index,
						   sizeof(*ignore_index));
unknown's avatar
unknown committed
3386 3387

  /* check that used name is unique */
3388
  if (lock_type != TL_IGNORE)
unknown's avatar
unknown committed
3389
  {
unknown's avatar
unknown committed
3390 3391
    for (TABLE_LIST *tables=(TABLE_LIST*) thd->lex.select->table_list.first ;
	 tables ;
unknown's avatar
unknown committed
3392
	 tables=tables->next)
unknown's avatar
unknown committed
3393
    {
3394
      if (!strcmp(alias_str,tables->alias) && !strcmp(ptr->db, tables->db))
unknown's avatar
unknown committed
3395
      {
3396 3397
	net_printf(&thd->net,ER_NONUNIQ_TABLE,alias_str); /* purecov: tested */
	DBUG_RETURN(0);				/* purecov: tested */
unknown's avatar
unknown committed
3398
      }
unknown's avatar
unknown committed
3399 3400
    }
  }
unknown's avatar
unknown committed
3401
  thd->lex.select->table_list.link_in_list((byte*) ptr,(byte**) &ptr->next);
unknown's avatar
unknown committed
3402 3403 3404
  DBUG_RETURN(ptr);
}

unknown's avatar
unknown committed
3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435
/*
  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
*/

void set_lock_for_tables(thr_lock_type lock_type)
{
  THD	*thd=current_thd;
  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));

  for (TABLE_LIST *tables= (TABLE_LIST*) thd->lex.select->table_list.first ;
       tables ;
       tables=tables->next)
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
3436 3437 3438 3439 3440 3441 3442

/*
** This is used for UNION to create a new table list of all used tables
** The table_list->table entry in all used tables are set to point
** to the entries in this list.
*/

unknown's avatar
unknown committed
3443
static bool create_total_list(THD *thd, LEX *lex, TABLE_LIST **result)
3444
{
3445 3446 3447 3448 3449 3450 3451
  /* Handle the case when we are not using union */
  if (!lex->select_lex.next)
  {
    *result= (TABLE_LIST*) lex->select_lex.table_list.first;
    return 0;
  }

unknown's avatar
unknown committed
3452 3453
  SELECT_LEX *sl;
  TABLE_LIST **new_table_list= result, *aux;
unknown's avatar
unknown committed
3454

unknown's avatar
unknown committed
3455
  *new_table_list=0;				// end result list
3456
  for (sl= &lex->select_lex; sl; sl=sl->next)
3457
  {
3458
    if (sl->order_list.first && sl->next && !sl->braces)
3459
    {
unknown's avatar
unknown committed
3460 3461
      net_printf(&thd->net,ER_WRONG_USAGE,"UNION","ORDER BY");
      return 1;
3462
    }
3463
    if ((aux= (TABLE_LIST*) sl->table_list.first))
3464
    {
unknown's avatar
unknown committed
3465 3466
      TABLE_LIST *next;
      for (; aux; aux=next)
3467
      {
unknown's avatar
unknown committed
3468 3469 3470 3471
	TABLE_LIST *cursor;
	next= aux->next;
	for (cursor= *result; cursor; cursor=cursor->next)
	  if (!strcmp(cursor->db,aux->db) &&
3472
	      !strcmp(cursor->real_name,aux->real_name) &&
3473
	      !strcmp(cursor->alias, aux->alias))
unknown's avatar
unknown committed
3474 3475 3476 3477
	    break;
	if (!cursor)
	{
	  /* Add not used table to the total table list */
unknown's avatar
unknown committed
3478
	  if (!(cursor = (TABLE_LIST *) thd->memdup((char*) aux,
unknown's avatar
unknown committed
3479
						    sizeof(*aux))))
unknown's avatar
unknown committed
3480 3481 3482 3483
	  {
	    send_error(&thd->net,0);
	    return 1;
	  }
unknown's avatar
unknown committed
3484 3485
	  *new_table_list= cursor;
	  new_table_list= &cursor->next;
3486
	  *new_table_list=0;			// end result list
unknown's avatar
unknown committed
3487
	}
3488 3489
	else
	  aux->shared=1;			// Mark that it's used twice
unknown's avatar
unknown committed
3490
	aux->table= my_reinterpret_cast(TABLE *) (cursor);
3491 3492 3493
      }
    }
  }
unknown's avatar
unknown committed
3494
  return 0;
3495 3496
}

unknown's avatar
unknown committed
3497

unknown's avatar
unknown committed
3498 3499
void add_join_on(TABLE_LIST *b,Item *expr)
{
3500
  if (expr)
3501
  {
3502 3503 3504 3505 3506 3507 3508 3509
    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();
3510
  }
unknown's avatar
unknown committed
3511 3512 3513
}


3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531
/*
  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
3532 3533 3534 3535 3536 3537 3538
void add_join_natural(TABLE_LIST *a,TABLE_LIST *b)
{
  b->natural_join=a;
}

	/* Check if name is used in table list */

unknown's avatar
unknown committed
3539
static bool check_dup(const char *db, const char *name, TABLE_LIST *tables)
unknown's avatar
unknown committed
3540 3541
{
  for (; tables ; tables=tables->next)
3542
    if (!strcmp(name,tables->real_name) && !strcmp(db,tables->db))
unknown's avatar
unknown committed
3543 3544 3545 3546
      return 1;
  return 0;
}

3547 3548 3549 3550 3551

/*
  Reload/resets privileges and the different caches
*/

unknown's avatar
unknown committed
3552
bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables)
unknown's avatar
unknown committed
3553 3554
{
  bool result=0;
3555
  bool error_already_sent=0;
unknown's avatar
unknown committed
3556 3557 3558
  select_errors=0;				/* Write if more errors */
  if (options & REFRESH_GRANT)
  {
3559
    acl_reload(thd);
unknown's avatar
unknown committed
3560
    grant_reload(thd);
3561
    if (mqh_used)
3562
      reset_mqh(thd,(LEX_USER *) NULL,true);
unknown's avatar
unknown committed
3563 3564 3565
  }
  if (options & REFRESH_LOG)
  {
unknown's avatar
unknown committed
3566 3567 3568 3569
    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
3570 3571
    if (ha_flush_logs())
      result=1;
unknown's avatar
unknown committed
3572 3573
    if (flush_error_log())
      result=1;
unknown's avatar
unknown committed
3574
  }
unknown's avatar
unknown committed
3575
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
3576 3577
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
unknown's avatar
unknown committed
3578
    query_cache.pack();				// FLUSH QUERY CACHE
unknown's avatar
unknown committed
3579 3580 3581 3582
    options &= ~REFRESH_QUERY_CACHE; //don't flush all cache, just free memory
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
unknown's avatar
unknown committed
3583
    query_cache.flush();			// RESET QUERY CACHE
unknown's avatar
unknown committed
3584
  }
unknown's avatar
unknown committed
3585
#endif /*HAVE_QUERY_CACHE*/
unknown's avatar
unknown committed
3586 3587
  if (options & (REFRESH_TABLES | REFRESH_READ_LOCK))
  {
3588
    if ((options & REFRESH_READ_LOCK) && thd)
unknown's avatar
unknown committed
3589
    {
3590 3591
      if (lock_global_read_lock(thd))
	return 1;
unknown's avatar
unknown committed
3592
    }
unknown's avatar
unknown committed
3593
    result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
unknown's avatar
unknown committed
3594 3595 3596 3597 3598 3599 3600 3601
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
  if (options & REFRESH_STATUS)
    refresh_status();
  if (options & REFRESH_THREADS)
    flush_thread_cache();
  if (options & REFRESH_MASTER)
3602 3603
    if (reset_master(thd))
      result=1;
unknown's avatar
unknown committed
3604
#ifdef OPENSSL
3605 3606 3607 3608 3609 3610
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
3611 3612 3613
 if (options & REFRESH_SLAVE)
 {
   LOCK_ACTIVE_MI;
3614
   if (reset_slave(thd, active_mi))
3615
   {
3616
     result=1;
3617 3618 3619 3620 3621 3622 3623 3624
     /*
       reset_slave() sends error itself.
       If it didn't, one would either change reset_slave()'s prototype, to
       pass *errorcode and *errmsg to it when it's called or
       change reset_slave to use my_error() to register the error.
     */
     error_already_sent=1;
   }
3625 3626 3627
   UNLOCK_ACTIVE_MI;
 }
 if (options & REFRESH_USER_RESOURCES)
3628
   reset_mqh(thd,(LEX_USER *) NULL);
3629 3630 3631 3632 3633 3634 3635 3636 3637

 if (thd && !error_already_sent)
 {
   if (result)
     send_error(&thd->net,0);
   else
     send_ok(&thd->net);
 }

3638
 return result;
unknown's avatar
unknown committed
3639 3640 3641
}


3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653
/*
  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
*/

3654
void kill_one_thread(THD *thd, ulong id)
unknown's avatar
unknown committed
3655 3656 3657
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
3658 3659
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  I_List_iterator<THD> it(threads);
unknown's avatar
unknown committed
3660 3661 3662 3663
  while ((tmp=it++))
  {
    if (tmp->thread_id == id)
    {
3664 3665
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
unknown's avatar
unknown committed
3666 3667 3668
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681
  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
3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701
  if (!error)
    send_ok(&thd->net);
  else
    net_printf(&thd->net,error,id);
}

/* Clear most status variables */

static void refresh_status(void)
{
  pthread_mutex_lock(&THR_LOCK_keycache);
  pthread_mutex_lock(&LOCK_status);
  for (struct show_var_st *ptr=status_vars; ptr->name; ptr++)
  {
    if (ptr->type == SHOW_LONG)
      *(ulong*) ptr->value=0;
  }
  pthread_mutex_unlock(&LOCK_status);
  pthread_mutex_unlock(&THR_LOCK_keycache);
}
3702 3703 3704 3705


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

unknown's avatar
unknown committed
3706
static bool append_file_to_dir(THD *thd, char **filename_ptr, char *table_name)
3707
{
3708
  char buff[FN_REFLEN],*ptr, *end;
3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720
  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))
  {
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
3721
  end=convert_dirname(buff, *filename_ptr, NullS);
unknown's avatar
unknown committed
3722
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
3723 3724
    return 1;					// End of memory
  *filename_ptr=ptr;
3725
  strxmov(ptr,buff,table_name,NullS);
3726 3727
  return 0;
}
3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752

/*
  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;
  if (thd->lex.select != &thd->lex.select_lex)
  {
    char command[80];
    strmake(command, thd->lex.yylval->symbol.str,
	    min(thd->lex.yylval->symbol.length, sizeof(command)-1));
    net_printf(&thd->net, ER_CANT_USE_OPTION_HERE, command);
    return 1;
  }
  return 0;
}