libmysql.c 143 KB
Newer Older
unknown's avatar
unknown committed
1 2 3 4 5 6 7 8
/* Copyright (C) 2000 MySQL AB

   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.

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

   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 */
unknown's avatar
unknown committed
16

unknown's avatar
unknown committed
17
#include <my_global.h>
unknown's avatar
unknown committed
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
#if defined(__WIN__) || defined(_WIN32) || defined(_WIN64)
#include <winsock.h>
#include <odbcinst.h>
#endif
#include <my_sys.h>
#include <mysys_err.h>
#include <m_string.h>
#include <m_ctype.h>
#include "mysql.h"
#include "mysql_version.h"
#include "mysqld_error.h"
#include "errmsg.h"
#include <violite.h>
#include <sys/stat.h>
#include <signal.h>
#include <time.h>
34
#include <assert.h> /* for DBUG_ASSERT() */
unknown's avatar
unknown committed
35 36 37 38 39 40 41 42 43
#ifdef	 HAVE_PWD_H
#include <pwd.h>
#endif
#if !defined(MSDOS) && !defined(__WIN__)
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#ifdef HAVE_SELECT_H
44
#include <select.h>
unknown's avatar
unknown committed
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
#endif
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#endif
#ifdef HAVE_SYS_UN_H
#  include <sys/un.h>
#endif
#if defined(THREAD) && !defined(__WIN__)
#include <my_pthread.h>				/* because of signal()	*/
#endif
#ifndef INADDR_NONE
#define INADDR_NONE	-1
#endif

static my_bool	mysql_client_init=0;
uint		mysql_port=0;
my_string	mysql_unix_port=0;
unknown's avatar
unknown committed
63
ulong 		net_buffer_length=8192;
64
ulong		max_allowed_packet= 1024L*1024L*1024L;
unknown's avatar
unknown committed
65 66
ulong		net_read_timeout=  NET_READ_TIMEOUT;
ulong		net_write_timeout= NET_WRITE_TIMEOUT;
unknown's avatar
unknown committed
67

68 69
#define CLIENT_CAPABILITIES (CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG	  \
                             | CLIENT_LOCAL_FILES   | CLIENT_TRANSACTIONS \
70
			     | CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION)
71

unknown's avatar
unknown committed
72

73 74 75 76 77 78
#ifdef __WIN__
#define CONNECT_TIMEOUT 20
#else
#define CONNECT_TIMEOUT 0
#endif

unknown's avatar
unknown committed
79
#if defined(MSDOS) || defined(__WIN__)
unknown's avatar
unknown committed
80
// socket_errno is defined in my_global.h for all platforms
unknown's avatar
unknown committed
81 82 83 84
#define perror(A)
#else
#include <errno.h>
#define SOCKET_ERROR -1
unknown's avatar
unknown committed
85
#endif /* __WIN__ */
unknown's avatar
unknown committed
86

87 88 89 90 91 92 93 94 95
#ifdef HAVE_SMEM
char *shared_memory_base_name=0;
const char *def_shared_memory_base_name=default_shared_memory_base_name;
#endif

const char *sql_protocol_names_lib[] =
{ "TCP", "SOCKET", "PIPE", "MEMORY",NullS };
TYPELIB sql_protocol_typelib = {array_elements(sql_protocol_names_lib)-1,"",
			   sql_protocol_names_lib};
96 97 98 99 100
/*
  If allowed through some configuration, then this needs to
  be changed
*/
#define MAX_LONG_DATA_LENGTH 8192
101 102 103
#define protocol_41(A) ((A)->server_capabilities & CLIENT_PROTOCOL_41)
#define unsigned_field(A) ((A)->flags & UNSIGNED_FLAG)

unknown's avatar
unknown committed
104 105 106 107 108 109 110 111 112
static void mysql_once_init(void);
static MYSQL_DATA *read_rows (MYSQL *mysql,MYSQL_FIELD *fields,
			      uint field_count);
static int read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row,
			ulong *lengths);
static void end_server(MYSQL *mysql);
static void read_user_name(char *name);
static void append_wild(char *to,char *end,const char *wild);
static my_bool mysql_reconnect(MYSQL *mysql);
113
static my_bool send_file_to_server(MYSQL *mysql,const char *filename);
unknown's avatar
unknown committed
114 115 116
static sig_handler pipe_sig_handler(int sig);
static ulong mysql_sub_escape_string(CHARSET_INFO *charset_info, char *to,
				     const char *from, ulong length);
unknown's avatar
unknown committed
117
static my_bool stmt_close(MYSQL_STMT *stmt, my_bool skip_list);
unknown's avatar
unknown committed
118

119 120
static my_bool org_my_init_done=0;

121 122 123
int STDCALL mysql_server_init(int argc __attribute__((unused)),
			      char **argv __attribute__((unused)),
			      char **groups __attribute__((unused)))
unknown's avatar
unknown committed
124 125 126
{
  return 0;
}
unknown's avatar
unknown committed
127

128
void STDCALL mysql_server_end()
129 130 131 132 133
{
  /* If library called my_init(), free memory allocated by it */
  if (!org_my_init_done)
    my_end(0);
}
unknown's avatar
unknown committed
134

135
my_bool STDCALL mysql_thread_init()
unknown's avatar
unknown committed
136 137 138 139 140 141 142 143
{
#ifdef THREAD
    return my_thread_init();
#else
    return 0;
#endif
}

144
void STDCALL mysql_thread_end()
unknown's avatar
unknown committed
145 146 147 148 149 150
{
#ifdef THREAD
    my_thread_end();
#endif
}

unknown's avatar
unknown committed
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
/*
  Let the user specify that we don't want SIGPIPE;  This doesn't however work
  with threaded applications as we can have multiple read in progress.
*/

#if !defined(__WIN__) && defined(SIGPIPE) && !defined(THREAD)
#define init_sigpipe_variables  sig_return old_signal_handler=(sig_return) 0;
#define set_sigpipe(mysql)     if ((mysql)->client_flag & CLIENT_IGNORE_SIGPIPE) old_signal_handler=signal(SIGPIPE,pipe_sig_handler)
#define reset_sigpipe(mysql) if ((mysql)->client_flag & CLIENT_IGNORE_SIGPIPE) signal(SIGPIPE,old_signal_handler);
#else
#define init_sigpipe_variables
#define set_sigpipe(mysql)
#define reset_sigpipe(mysql)
#endif

166 167 168 169 170 171
static MYSQL* spawn_init(MYSQL* parent, const char* host,
			 unsigned int port,
			 const char* user,
			 const char* passwd);


unknown's avatar
unknown committed
172
/****************************************************************************
173
  A modified version of connect().  my_connect() allows you to specify
174 175 176 177 178
  a timeout value, in seconds, that we should wait until we
  derermine we can't connect to a particular host.  If timeout is 0,
  my_connect() will behave exactly like connect().

  Base version coded by Steve Bernacki, Jr. <steve@navinet.net>
unknown's avatar
unknown committed
179 180
*****************************************************************************/

181 182
my_bool my_connect(my_socket s, const struct sockaddr *name,
		   uint namelen, uint timeout)
unknown's avatar
unknown committed
183
{
unknown's avatar
unknown committed
184
#if defined(__WIN__) || defined(OS2)
185
  return connect(s, (struct sockaddr*) name, namelen) != 0;
unknown's avatar
unknown committed
186 187
#else
  int flags, res, s_err;
unknown's avatar
unknown committed
188
  SOCKOPT_OPTLEN_TYPE s_err_size = sizeof(uint);
unknown's avatar
unknown committed
189 190 191 192 193 194 195 196
  fd_set sfds;
  struct timeval tv;
  time_t start_time, now_time;

  /* If they passed us a timeout of zero, we should behave
   * exactly like the normal connect() call does.
   */

197
  if (timeout == 0)
198
    return connect(s, (struct sockaddr*) name, namelen) != 0;
unknown's avatar
unknown committed
199 200 201 202 203 204 205 206 207 208 209 210

  flags = fcntl(s, F_GETFL, 0);		  /* Set socket to not block */
#ifdef O_NONBLOCK
  fcntl(s, F_SETFL, flags | O_NONBLOCK);  /* and save the flags..  */
#endif

  res = connect(s, (struct sockaddr*) name, namelen);
  s_err = errno;			/* Save the error... */
  fcntl(s, F_SETFL, flags);
  if ((res != 0) && (s_err != EINPROGRESS))
  {
    errno = s_err;			/* Restore it */
211
    return(1);
unknown's avatar
unknown committed
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
  }
  if (res == 0)				/* Connected quickly! */
    return(0);

  /* Otherwise, our connection is "in progress."  We can use
   * the select() call to wait up to a specified period of time
   * for the connection to suceed.  If select() returns 0
   * (after waiting howevermany seconds), our socket never became
   * writable (host is probably unreachable.)  Otherwise, if
   * select() returns 1, then one of two conditions exist:
   *
   * 1. An error occured.  We use getsockopt() to check for this.
   * 2. The connection was set up sucessfully: getsockopt() will
   * return 0 as an error.
   *
   * Thanks goes to Andrew Gierth <andrew@erlenstar.demon.co.uk>
   * who posted this method of timing out a connect() in
   * comp.unix.programmer on August 15th, 1997.
   */

  FD_ZERO(&sfds);
  FD_SET(s, &sfds);
  /*
unknown's avatar
unknown committed
235
   * select could be interrupted by a signal, and if it is,
unknown's avatar
unknown committed
236
   * the timeout should be adjusted and the select restarted
unknown's avatar
unknown committed
237
   * to work around OSes that don't restart select and
unknown's avatar
unknown committed
238 239 240 241 242 243
   * implementations of select that don't adjust tv upon
   * failure to reflect the time remaining
   */
  start_time = time(NULL);
  for (;;)
  {
244
    tv.tv_sec = (long) timeout;
unknown's avatar
unknown committed
245
    tv.tv_usec = 0;
246
#if defined(HPUX10) && defined(THREAD)
unknown's avatar
unknown committed
247 248 249
    if ((res = select(s+1, NULL, (int*) &sfds, NULL, &tv)) >= 0)
      break;
#else
unknown's avatar
unknown committed
250 251
    if ((res = select(s+1, NULL, &sfds, NULL, &tv)) >= 0)
      break;
unknown's avatar
unknown committed
252
#endif
unknown's avatar
unknown committed
253
    now_time=time(NULL);
254 255
    timeout-= (uint) (now_time - start_time);
    if (errno != EINTR || (int) timeout <= 0)
256
      return 1;
unknown's avatar
unknown committed
257 258 259 260 261 262 263 264 265
  }

  /* select() returned something more interesting than zero, let's
   * see if we have any errors.  If the next two statements pass,
   * we've got an open socket!
   */

  s_err=0;
  if (getsockopt(s, SOL_SOCKET, SO_ERROR, (char*) &s_err, &s_err_size) != 0)
266
    return(1);
unknown's avatar
unknown committed
267 268

  if (s_err)
269
  {						/* getsockopt could succeed */
unknown's avatar
unknown committed
270
    errno = s_err;
271
    return(1);					/* but return an error... */
unknown's avatar
unknown committed
272 273 274 275 276 277
  }
  return(0);					/* It's all good! */
#endif
}

/*
278
  Create a named pipe connection
unknown's avatar
unknown committed
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
*/

#ifdef __WIN__

HANDLE create_named_pipe(NET *net, uint connect_timeout, char **arg_host,
			 char **arg_unix_socket)
{
  HANDLE hPipe=INVALID_HANDLE_VALUE;
  char szPipeName [ 257 ];
  DWORD dwMode;
  int i;
  my_bool testing_named_pipes=0;
  char *host= *arg_host, *unix_socket= *arg_unix_socket;

  if ( ! unix_socket || (unix_socket)[0] == 0x00)
    unix_socket = mysql_unix_port;
  if (!host || !strcmp(host,LOCAL_HOST))
    host=LOCAL_HOST_NAMEDPIPE;

  sprintf( szPipeName, "\\\\%s\\pipe\\%s", host, unix_socket);
  DBUG_PRINT("info",("Server name: '%s'.  Named Pipe: %s",
		     host, unix_socket));

  for (i=0 ; i < 100 ; i++)			/* Don't retry forever */
  {
    if ((hPipe = CreateFile(szPipeName,
			    GENERIC_READ | GENERIC_WRITE,
			    0,
			    NULL,
			    OPEN_EXISTING,
			    0,
			    NULL )) != INVALID_HANDLE_VALUE)
      break;
    if (GetLastError() != ERROR_PIPE_BUSY)
    {
      net->last_errno=CR_NAMEDPIPEOPEN_ERROR;
      sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
	      (ulong) GetLastError());
      return INVALID_HANDLE_VALUE;
    }
    /* wait for for an other instance */
    if (! WaitNamedPipe(szPipeName, connect_timeout*1000) )
    {
      net->last_errno=CR_NAMEDPIPEWAIT_ERROR;
      sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
	      (ulong) GetLastError());
      return INVALID_HANDLE_VALUE;
    }
  }
  if (hPipe == INVALID_HANDLE_VALUE)
  {
    net->last_errno=CR_NAMEDPIPEOPEN_ERROR;
    sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
	    (ulong) GetLastError());
    return INVALID_HANDLE_VALUE;
  }
  dwMode = PIPE_READMODE_BYTE | PIPE_WAIT;
  if ( !SetNamedPipeHandleState(hPipe, &dwMode, NULL, NULL) )
  {
    CloseHandle( hPipe );
    net->last_errno=CR_NAMEDPIPESETSTATE_ERROR;
    sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
	    (ulong) GetLastError());
    return INVALID_HANDLE_VALUE;
  }
  *arg_host=host ; *arg_unix_socket=unix_socket;	/* connect arg */
  return (hPipe);
}
#endif

unknown's avatar
unknown committed
349
/*
350 351 352 353 354
  Create new shared memory connection, return handler of connection

  SYNOPSIS
    create_shared_memory()
    mysql  Pointer of mysql structure
unknown's avatar
unknown committed
355
    net    Pointer of net structure
356 357 358 359 360 361
    connect_timeout Timeout of connection
*/
#ifdef HAVE_SMEM
HANDLE create_shared_memory(MYSQL *mysql,NET *net, uint connect_timeout)
{
  ulong smem_buffer_length = shared_memory_buffer_length + 4;
unknown's avatar
unknown committed
362 363
/*
  event_connect_request is event object for start connection actions
364
  event_connect_answer is event object for confirm, that server put data
unknown's avatar
unknown committed
365
  handle_connect_file_map is file-mapping object, use for create shared memory
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
  handle_connect_map is pointer on shared memory
  handle_map is pointer on shared memory for client
  event_server_wrote,
  event_server_read,
  event_client_wrote,
  event_client_read are events for transfer data between server and client
  handle_file_map is file-mapping object, use for create shared memory
*/
  HANDLE event_connect_request = NULL;
  HANDLE event_connect_answer = NULL;
  HANDLE handle_connect_file_map = NULL;
  char *handle_connect_map = NULL;

  char *handle_map = NULL;
  HANDLE event_server_wrote = NULL;
  HANDLE event_server_read = NULL;
  HANDLE event_client_wrote = NULL;
  HANDLE event_client_read = NULL;
  HANDLE handle_file_map = NULL;
unknown's avatar
unknown committed
385
  ulong connect_number;
386 387
  char connect_number_char[22], *p;
  char tmp[64];
unknown's avatar
unknown committed
388
  char *suffix_pos;
389 390 391 392 393 394 395 396 397 398 399 400 401
  DWORD error_allow = 0;
  DWORD error_code = 0;
  char *shared_memory_base_name = mysql->options.shared_memory_base_name;

/*
  The name of event and file-mapping events create agree next rule:
            shared_memory_base_name+unique_part
  Where:
    shared_memory_base_name is unique value for each server
    unique_part is uniquel value for each object (events and file-mapping)
*/
  suffix_pos = strxmov(tmp,shared_memory_base_name,"_",NullS);
  strmov(suffix_pos, "CONNECT_REQUEST");
unknown's avatar
unknown committed
402
  if ((event_connect_request = OpenEvent(EVENT_ALL_ACCESS,FALSE,tmp)) == NULL)
403 404 405 406 407
  {
    error_allow = CR_SHARED_MEMORY_CONNECT_REQUEST_ERROR;
    goto err;
  }
  strmov(suffix_pos, "CONNECT_ANSWER");
unknown's avatar
unknown committed
408
  if ((event_connect_answer = OpenEvent(EVENT_ALL_ACCESS,FALSE,tmp)) == NULL)
409 410 411 412 413
  {
    error_allow = CR_SHARED_MEMORY_CONNECT_ANSWER_ERROR;
    goto err;
  }
  strmov(suffix_pos, "CONNECT_DATA");
unknown's avatar
unknown committed
414
  if ((handle_connect_file_map = OpenFileMapping(FILE_MAP_WRITE,FALSE,tmp)) == NULL)
415 416 417 418
  {
    error_allow = CR_SHARED_MEMORY_CONNECT_FILE_MAP_ERROR;
    goto err;
  }
unknown's avatar
unknown committed
419
  if ((handle_connect_map = MapViewOfFile(handle_connect_file_map,FILE_MAP_WRITE,0,0,sizeof(DWORD))) == NULL)
420 421 422 423 424 425 426
  {
    error_allow = CR_SHARED_MEMORY_CONNECT_MAP_ERROR;
    goto err;
  }
/*
 Send to server request of connection
*/
unknown's avatar
unknown committed
427
  if (!SetEvent(event_connect_request))
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
  {
    error_allow = CR_SHARED_MEMORY_CONNECT_SET_ERROR;
    goto err;
  }
/*
  Wait of answer from server
*/
  if (WaitForSingleObject(event_connect_answer,connect_timeout*1000) != WAIT_OBJECT_0)
  {
    error_allow = CR_SHARED_MEMORY_CONNECT_ABANDODED_ERROR;
    goto err;
  }
/*
  Get number of connection
*/
  connect_number = uint4korr(handle_connect_map);/*WAX2*/
  p = int2str(connect_number, connect_number_char, 10);

/*
  The name of event and file-mapping events create agree next rule:
    shared_memory_base_name+unique_part+number_of_connection
  Where:
    shared_memory_base_name is uniquel value for each server
    unique_part is uniquel value for each object (events and file-mapping)
    number_of_connection is number of connection between server and client
*/
unknown's avatar
unknown committed
454 455
  suffix_pos = strxmov(tmp,shared_memory_base_name,"_",connect_number_char,
		       "_",NullS);
456 457 458 459
  strmov(suffix_pos, "DATA");
  if ((handle_file_map = OpenFileMapping(FILE_MAP_WRITE,FALSE,tmp)) == NULL)
  {
    error_allow = CR_SHARED_MEMORY_FILE_MAP_ERROR;
unknown's avatar
unknown committed
460
    goto err2;
461
  }
unknown's avatar
unknown committed
462 463
  if ((handle_map = MapViewOfFile(handle_file_map,FILE_MAP_WRITE,0,0,
				  smem_buffer_length)) == NULL)
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
  {
    error_allow = CR_SHARED_MEMORY_MAP_ERROR;
    goto err2;
  }

  strmov(suffix_pos, "SERVER_WROTE");
  if ((event_server_wrote = OpenEvent(EVENT_ALL_ACCESS,FALSE,tmp)) == NULL)
  {
    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;
    goto err2;
  }

  strmov(suffix_pos, "SERVER_READ");
  if ((event_server_read = OpenEvent(EVENT_ALL_ACCESS,FALSE,tmp)) == NULL)
  {
    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;
    goto err2;
  }

  strmov(suffix_pos, "CLIENT_WROTE");
  if ((event_client_wrote = OpenEvent(EVENT_ALL_ACCESS,FALSE,tmp)) == NULL)
  {
    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;
    goto err2;
  }

  strmov(suffix_pos, "CLIENT_READ");
  if ((event_client_read = OpenEvent(EVENT_ALL_ACCESS,FALSE,tmp)) == NULL)
  {
    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;
    goto err2;
  }
/*
  Set event that server should send data
*/
  SetEvent(event_server_read);

unknown's avatar
unknown committed
501 502
err2:
  if (error_allow == 0)
503 504
  {
    net->vio = vio_new_win32shared_memory(net,handle_file_map,handle_map,event_server_wrote,
unknown's avatar
unknown committed
505 506 507
                                          event_server_read,event_client_wrote,event_client_read);
  }
  else
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
  {
    error_code = GetLastError();
    if (event_server_read) CloseHandle(event_server_read);
    if (event_server_wrote) CloseHandle(event_server_wrote);
    if (event_client_read) CloseHandle(event_client_read);
    if (event_client_wrote) CloseHandle(event_client_wrote);
    if (handle_map) UnmapViewOfFile(handle_map);
    if (handle_file_map) CloseHandle(handle_file_map);
  }
err:
  if (error_allow) error_code = GetLastError();
  if (event_connect_request) CloseHandle(event_connect_request);
  if (event_connect_answer) CloseHandle(event_connect_answer);
  if (handle_connect_map) UnmapViewOfFile(handle_connect_map);
  if (handle_connect_file_map) CloseHandle(handle_connect_file_map);
unknown's avatar
unknown committed
523
  if (error_allow)
524 525 526 527 528 529 530
  {
    net->last_errno=error_allow;
    if (error_allow == CR_SHARED_MEMORY_EVENT_ERROR)
      sprintf(net->last_error,ER(net->last_errno),suffix_pos,error_code);
    else
      sprintf(net->last_error,ER(net->last_errno),error_code);
    return(INVALID_HANDLE_VALUE);
unknown's avatar
unknown committed
531
  }
532 533 534
  return(handle_map);
};
#endif
unknown's avatar
unknown committed
535 536

/*****************************************************************************
537 538
  read a packet from server. Give error message if socket was down
  or packet is an error message
unknown's avatar
unknown committed
539 540
*****************************************************************************/

unknown's avatar
unknown committed
541
ulong
unknown's avatar
unknown committed
542 543 544
net_safe_read(MYSQL *mysql)
{
  NET *net= &mysql->net;
unknown's avatar
unknown committed
545
  ulong len=0;
unknown's avatar
unknown committed
546 547 548 549 550 551 552 553 554 555 556 557 558
  init_sigpipe_variables

  /* Don't give sigpipe errors if the client doesn't want them */
  set_sigpipe(mysql);
  if (net->vio != 0)
    len=my_net_read(net);
  reset_sigpipe(mysql);

  if (len == packet_error || len == 0)
  {
    DBUG_PRINT("error",("Wrong connection or packet. fd: %s  len: %d",
			vio_description(net->vio),len));
    end_server(mysql);
unknown's avatar
unknown committed
559
    net->last_errno=(net->last_errno == ER_NET_PACKET_TOO_LARGE ?
unknown's avatar
unknown committed
560 561 562
		     CR_NET_PACKET_TOO_LARGE:
		     CR_SERVER_LOST);
    strmov(net->last_error,ER(net->last_errno));
unknown's avatar
unknown committed
563
    return (packet_error);
unknown's avatar
unknown committed
564 565 566 567 568 569
  }
  if (net->read_pos[0] == 255)
  {
    if (len > 3)
    {
      char *pos=(char*) net->read_pos+1;
570 571 572
      net->last_errno=uint2korr(pos);
      pos+=2;
      len-=2;
unknown's avatar
unknown committed
573
      (void) strmake(net->last_error,(char*) pos,
unknown's avatar
unknown committed
574
		     min((uint) len,(uint) sizeof(net->last_error)-1));
unknown's avatar
unknown committed
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656
    }
    else
    {
      net->last_errno=CR_UNKNOWN_ERROR;
      (void) strmov(net->last_error,ER(net->last_errno));
    }
    DBUG_PRINT("error",("Got error: %d (%s)", net->last_errno,
			net->last_error));
    return(packet_error);
  }
  return len;
}


/* Get the length of next field. Change parameter to point at fieldstart */
static ulong
net_field_length(uchar **packet)
{
  reg1 uchar *pos= *packet;
  if (*pos < 251)
  {
    (*packet)++;
    return (ulong) *pos;
  }
  if (*pos == 251)
  {
    (*packet)++;
    return NULL_LENGTH;
  }
  if (*pos == 252)
  {
    (*packet)+=3;
    return (ulong) uint2korr(pos+1);
  }
  if (*pos == 253)
  {
    (*packet)+=4;
    return (ulong) uint3korr(pos+1);
  }
  (*packet)+=9;					/* Must be 254 when here */
  return (ulong) uint4korr(pos+1);
}

/* Same as above, but returns ulonglong values */

static my_ulonglong
net_field_length_ll(uchar **packet)
{
  reg1 uchar *pos= *packet;
  if (*pos < 251)
  {
    (*packet)++;
    return (my_ulonglong) *pos;
  }
  if (*pos == 251)
  {
    (*packet)++;
    return (my_ulonglong) NULL_LENGTH;
  }
  if (*pos == 252)
  {
    (*packet)+=3;
    return (my_ulonglong) uint2korr(pos+1);
  }
  if (*pos == 253)
  {
    (*packet)+=4;
    return (my_ulonglong) uint3korr(pos+1);
  }
  (*packet)+=9;					/* Must be 254 when here */
#ifdef NO_CLIENT_LONGLONG
  return (my_ulonglong) uint4korr(pos+1);
#else
  return (my_ulonglong) uint8korr(pos+1);
#endif
}


static void free_rows(MYSQL_DATA *cur)
{
  if (cur)
  {
657
    free_root(&cur->alloc,MYF(0));
unknown's avatar
unknown committed
658 659 660 661 662
    my_free((gptr) cur,MYF(0));
  }
}


663 664 665 666
static my_bool
advanced_command(MYSQL *mysql, enum enum_server_command command,
		 const char *header, ulong header_length,
		 const char *arg, ulong arg_length, my_bool skip_check)
unknown's avatar
unknown committed
667 668
{
  NET *net= &mysql->net;
669
  my_bool result= 1;
unknown's avatar
unknown committed
670 671 672 673
  init_sigpipe_variables

  /* Don't give sigpipe errors if the client doesn't want them */
  set_sigpipe(mysql);
674

unknown's avatar
unknown committed
675 676 677
  if (mysql->net.vio == 0)
  {						/* Do reconnect if possible */
    if (mysql_reconnect(mysql))
678
      return 1;
unknown's avatar
unknown committed
679 680 681 682
  }
  if (mysql->status != MYSQL_STATUS_READY)
  {
    strmov(net->last_error,ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
683
    return 1;
unknown's avatar
unknown committed
684 685 686 687 688 689
  }

  mysql->net.last_error[0]=0;
  mysql->net.last_errno=0;
  mysql->info=0;
  mysql->affected_rows= ~(my_ulonglong) 0;
690
  net_clear(&mysql->net);			/* Clear receive buffer */
unknown's avatar
unknown committed
691

692 693
  if (net_write_command(net,(uchar) command, header, header_length,
			arg, arg_length))
unknown's avatar
unknown committed
694
  {
695 696
    DBUG_PRINT("error",("Can't send command to server. Error: %d",
			socket_errno));
unknown's avatar
unknown committed
697
    end_server(mysql);
698 699
    if (mysql_reconnect(mysql))
      goto end;
700 701
    if (net_write_command(net,(uchar) command, header, header_length,
			  arg, arg_length))
unknown's avatar
unknown committed
702 703 704 705 706 707 708
    {
      net->last_errno=CR_SERVER_GONE_ERROR;
      strmov(net->last_error,ER(net->last_errno));
      goto end;
    }
  }
  result=0;
709
  if (!skip_check)
unknown's avatar
unknown committed
710
    result= ((mysql->packet_length=net_safe_read(mysql)) == packet_error ?
711
	     1 : 0);
unknown's avatar
unknown committed
712 713 714 715 716 717
 end:
  reset_sigpipe(mysql);
  return result;
}


718 719 720 721 722 723 724 725
my_bool
simple_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
	       ulong length, my_bool skip_check)
{
  return advanced_command(mysql, command, NullS, 0, arg, length, skip_check);
}


unknown's avatar
unknown committed
726 727 728 729
static void free_old_query(MYSQL *mysql)
{
  DBUG_ENTER("free_old_query");
  if (mysql->fields)
730 731
    free_root(&mysql->field_alloc,MYF(0));
  init_alloc_root(&mysql->field_alloc,8192,0);	/* Assume rowlength < 8192 */
unknown's avatar
unknown committed
732 733 734 735 736
  mysql->fields=0;
  mysql->field_count=0;				/* For API */
  DBUG_VOID_RETURN;
}

737

738
#if defined(HAVE_GETPWUID) && defined(NO_GETPWUID_DECL)
unknown's avatar
unknown committed
739 740 741 742
struct passwd *getpwuid(uid_t);
char* getlogin(void);
#endif

unknown's avatar
unknown committed
743
#if !defined(MSDOS) && ! defined(VMS) && !defined(__WIN__) && !defined(OS2)
unknown's avatar
unknown committed
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
static void read_user_name(char *name)
{
  DBUG_ENTER("read_user_name");
  if (geteuid() == 0)
    (void) strmov(name,"root");		/* allow use of surun */
  else
  {
#ifdef HAVE_GETPWUID
    struct passwd *skr;
    const char *str;
    if ((str=getlogin()) == NULL)
    {
      if ((skr=getpwuid(geteuid())) != NULL)
	str=skr->pw_name;
      else if (!(str=getenv("USER")) && !(str=getenv("LOGNAME")) &&
	       !(str=getenv("LOGIN")))
	str="UNKNOWN_USER";
    }
    (void) strmake(name,str,USERNAME_LENGTH);
#elif HAVE_CUSERID
    (void) cuserid(name);
#else
    strmov(name,"UNKNOWN_USER");
#endif
  }
  DBUG_VOID_RETURN;
}

#else /* If MSDOS || VMS */

static void read_user_name(char *name)
{
776 777
  char *str=getenv("USER");		/* ODBC will send user variable */
  strmake(name,str ? str : "ODBC", USERNAME_LENGTH);
unknown's avatar
unknown committed
778 779 780 781 782 783 784 785 786 787 788 789 790
}

#endif

#ifdef __WIN__
static my_bool is_NT(void)
{
  char *os=getenv("OS");
  return (os && !strcmp(os, "Windows_NT")) ? 1 : 0;
}
#endif

/*
791
  Expand wildcard to a sql string
unknown's avatar
unknown committed
792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
*/

static void
append_wild(char *to, char *end, const char *wild)
{
  end-=5;					/* Some extra */
  if (wild && wild[0])
  {
    to=strmov(to," like '");
    while (*wild && to < end)
    {
      if (*wild == '\\' || *wild == '\'')
	*to++='\\';
      *to++= *wild++;
    }
    if (*wild)					/* Too small buffer */
      *to++='%';				/* Nicer this way */
    to[0]='\'';
    to[1]=0;
  }
}


/**************************************************************************
816
  Init debugging if MYSQL_DEBUG environment variable is found
unknown's avatar
unknown committed
817 818 819
**************************************************************************/

void STDCALL
unknown's avatar
unknown committed
820
mysql_debug(const char *debug __attribute__((unused)))
unknown's avatar
unknown committed
821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852
{
#ifndef DBUG_OFF
  char	*env;
  if (_db_on_)
    return;					/* Already using debugging */
  if (debug)
  {
    DEBUGGER_ON;
    DBUG_PUSH(debug);
  }
  else if ((env = getenv("MYSQL_DEBUG")))
  {
    DEBUGGER_ON;
    DBUG_PUSH(env);
#if !defined(_WINVER) && !defined(WINVER)
    puts("\n-------------------------------------------------------");
    puts("MYSQL_DEBUG found. libmysql started with the following:");
    puts(env);
    puts("-------------------------------------------------------\n");
#else
    {
      char buff[80];
      strmov(strmov(buff,"libmysql: "),env);
      MessageBox((HWND) 0,"Debugging variable MYSQL_DEBUG used",buff,MB_OK);
    }
#endif
  }
#endif
}


/**************************************************************************
853
  Close the server connection if we get a SIGPIPE
unknown's avatar
unknown committed
854 855 856 857 858 859 860 861 862 863 864 865 866 867
   ARGSUSED
**************************************************************************/

static sig_handler
pipe_sig_handler(int sig __attribute__((unused)))
{
  DBUG_PRINT("info",("Hit by signal %d",sig));
#ifdef DONT_REMEMBER_SIGNAL
  (void) signal(SIGPIPE,pipe_sig_handler);
#endif
}


/**************************************************************************
868
  Shut down connection
unknown's avatar
unknown committed
869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898
**************************************************************************/

static void
end_server(MYSQL *mysql)
{
  DBUG_ENTER("end_server");
  if (mysql->net.vio != 0)
  {
    init_sigpipe_variables
    DBUG_PRINT("info",("Net: %s", vio_description(mysql->net.vio)));
    set_sigpipe(mysql);
    vio_delete(mysql->net.vio);
    reset_sigpipe(mysql);
    mysql->net.vio= 0;          /* Marker */
  }
  net_end(&mysql->net);
  free_old_query(mysql);
  DBUG_VOID_RETURN;
}


void STDCALL
mysql_free_result(MYSQL_RES *result)
{
  DBUG_ENTER("mysql_free_result");
  DBUG_PRINT("enter",("mysql_res: %lx",result));
  if (result)
  {
    if (result->handle && result->handle->status == MYSQL_STATUS_USE_RESULT)
    {
899
      DBUG_PRINT("warning",("Not all rows in set where read; Ignoring rows"));
unknown's avatar
unknown committed
900 901
      for (;;)
      {
unknown's avatar
unknown committed
902 903
	ulong pkt_len;
	if ((pkt_len=net_safe_read(result->handle)) == packet_error)
unknown's avatar
unknown committed
904
	  break;
905
	if (pkt_len <= 8 && result->handle->net.read_pos[0] == 254)
unknown's avatar
unknown committed
906 907 908 909 910 911
	  break;				/* End of data */
      }
      result->handle->status=MYSQL_STATUS_READY;
    }
    free_rows(result->data);
    if (result->fields)
912
      free_root(&result->field_alloc,MYF(0));
unknown's avatar
unknown committed
913 914 915 916 917 918 919 920 921
    if (result->row)
      my_free((gptr) result->row,MYF(0));
    my_free((gptr) result,MYF(0));
  }
  DBUG_VOID_RETURN;
}


/****************************************************************************
922
  Get options from my.cnf
unknown's avatar
unknown committed
923 924 925
****************************************************************************/

static const char *default_options[]=
926 927 928 929
{
  "port","socket","compress","password","pipe", "timeout", "user",
  "init-command", "host", "database", "debug", "return-found-rows",
  "ssl-key" ,"ssl-cert" ,"ssl-ca" ,"ssl-capath",
930
  "character-sets-dir", "default-character-set", "interactive-timeout",
931
  "connect-timeout", "local-infile", "disable-local-infile",
unknown's avatar
unknown committed
932
  "replication-probe", "enable-reads-from-master", "repl-parse-query",
933
  "ssl-cipher", "max-allowed-packet",
unknown's avatar
unknown committed
934
  "protocol", "shared-memory-base-name",
unknown's avatar
unknown committed
935
  NullS
unknown's avatar
unknown committed
936 937 938 939 940
};

static TYPELIB option_types={array_elements(default_options)-1,
			     "options",default_options};

unknown's avatar
unknown committed
941 942
static int add_init_command(struct st_mysql_options *options, const char *cmd)
{
unknown's avatar
unknown committed
943
  char *tmp;
unknown's avatar
unknown committed
944 945 946 947 948 949 950 951 952

  if (!options->init_commands)
  {
    options->init_commands= (DYNAMIC_ARRAY*)my_malloc(sizeof(DYNAMIC_ARRAY),
						      MYF(MY_WME));
    init_dynamic_array(options->init_commands,sizeof(char*),0,5 CALLER_INFO);
  }

  if (!(tmp= my_strdup(cmd,MYF(MY_WME))) ||
unknown's avatar
unknown committed
953
      insert_dynamic(options->init_commands, (gptr)&tmp))
unknown's avatar
unknown committed
954 955 956 957 958 959 960 961
  {
    my_free(tmp, MYF(MY_ALLOW_ZERO_PTR));
    return 1;
  }

  return 0;
}

unknown's avatar
unknown committed
962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989
static void mysql_read_default_options(struct st_mysql_options *options,
				       const char *filename,const char *group)
{
  int argc;
  char *argv_buff[1],**argv;
  const char *groups[3];
  DBUG_ENTER("mysql_read_default_options");
  DBUG_PRINT("enter",("file: %s  group: %s",filename,group ? group :"NULL"));

  argc=1; argv=argv_buff; argv_buff[0]= (char*) "client";
  groups[0]= (char*) "client"; groups[1]= (char*) group; groups[2]=0;

  load_defaults(filename, groups, &argc, &argv);
  if (argc != 1)				/* If some default option */
  {
    char **option=argv;
    while (*++option)
    {
      /* DBUG_PRINT("info",("option: %s",option[0])); */
      if (option[0][0] == '-' && option[0][1] == '-')
      {
	char *end=strcend(*option,'=');
	char *opt_arg=0;
	if (*end)
	{
	  opt_arg=end+1;
	  *end=0;				/* Remove '=' */
	}
990
	/* Change all '_' in variable name to '-' */
unknown's avatar
unknown committed
991
	for (end= *option ; *(end= strcend(end,'_')) ; )
992
	  *end= '-';
unknown's avatar
unknown committed
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
	switch (find_type(*option+2,&option_types,2)) {
	case 1:				/* port */
	  if (opt_arg)
	    options->port=atoi(opt_arg);
	  break;
	case 2:				/* socket */
	  if (opt_arg)
	  {
	    my_free(options->unix_socket,MYF(MY_ALLOW_ZERO_PTR));
	    options->unix_socket=my_strdup(opt_arg,MYF(MY_WME));
	  }
	  break;
	case 3:				/* compress */
	  options->compress=1;
1007
	  options->client_flag|= CLIENT_COMPRESS;
unknown's avatar
unknown committed
1008 1009 1010 1011 1012 1013 1014 1015
	  break;
	case 4:				/* password */
	  if (opt_arg)
	  {
	    my_free(options->password,MYF(MY_ALLOW_ZERO_PTR));
	    options->password=my_strdup(opt_arg,MYF(MY_WME));
	  }
	  break;
1016 1017
        case 5:
          options->protocol = MYSQL_PROTOCOL_PIPE;
1018
	case 20:			/* connect_timeout */
unknown's avatar
unknown committed
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
	case 6:				/* timeout */
	  if (opt_arg)
	    options->connect_timeout=atoi(opt_arg);
	  break;
	case 7:				/* user */
	  if (opt_arg)
	  {
	    my_free(options->user,MYF(MY_ALLOW_ZERO_PTR));
	    options->user=my_strdup(opt_arg,MYF(MY_WME));
	  }
	  break;
	case 8:				/* init-command */
unknown's avatar
unknown committed
1031
	  add_init_command(options,opt_arg);
unknown's avatar
unknown committed
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
	  break;
	case 9:				/* host */
	  if (opt_arg)
	  {
	    my_free(options->host,MYF(MY_ALLOW_ZERO_PTR));
	    options->host=my_strdup(opt_arg,MYF(MY_WME));
	  }
	  break;
	case 10:			/* database */
	  if (opt_arg)
	  {
	    my_free(options->db,MYF(MY_ALLOW_ZERO_PTR));
	    options->db=my_strdup(opt_arg,MYF(MY_WME));
	  }
	  break;
	case 11:			/* debug */
	  mysql_debug(opt_arg ? opt_arg : "d:t:o,/tmp/client.trace");
	  break;
	case 12:			/* return-found-rows */
	  options->client_flag|=CLIENT_FOUND_ROWS;
	  break;
#ifdef HAVE_OPENSSL
	case 13:			/* ssl_key */
	  my_free(options->ssl_key, MYF(MY_ALLOW_ZERO_PTR));
          options->ssl_key = my_strdup(opt_arg, MYF(MY_WME));
          break;
	case 14:			/* ssl_cert */
	  my_free(options->ssl_cert, MYF(MY_ALLOW_ZERO_PTR));
          options->ssl_cert = my_strdup(opt_arg, MYF(MY_WME));
          break;
	case 15:			/* ssl_ca */
	  my_free(options->ssl_ca, MYF(MY_ALLOW_ZERO_PTR));
          options->ssl_ca = my_strdup(opt_arg, MYF(MY_WME));
          break;
	case 16:			/* ssl_capath */
	  my_free(options->ssl_capath, MYF(MY_ALLOW_ZERO_PTR));
          options->ssl_capath = my_strdup(opt_arg, MYF(MY_WME));
          break;
#else
	case 13:				/* Ignore SSL options */
	case 14:
	case 15:
	case 16:
	  break;
#endif /* HAVE_OPENSSL */
	case 17:			/* charset-lib */
	  my_free(options->charset_dir,MYF(MY_ALLOW_ZERO_PTR));
          options->charset_dir = my_strdup(opt_arg, MYF(MY_WME));
	  break;
	case 18:
	  my_free(options->charset_name,MYF(MY_ALLOW_ZERO_PTR));
          options->charset_name = my_strdup(opt_arg, MYF(MY_WME));
	  break;
1085
	case 19:				/* Interactive-timeout */
1086 1087 1088 1089 1090 1091 1092
	  options->client_flag|= CLIENT_INTERACTIVE;
	  break;
	case 21:
	  if (!opt_arg || atoi(opt_arg) != 0)
	    options->client_flag|= CLIENT_LOCAL_FILES;
	  else
	    options->client_flag&= ~CLIENT_LOCAL_FILES;
1093
	  break;
1094 1095
	case 22:
	  options->client_flag&= CLIENT_LOCAL_FILES;
unknown's avatar
unknown committed
1096 1097
          break;
	case 23:  /* replication probe */
1098
	  options->rpl_probe= 1;
1099
	  break;
unknown's avatar
unknown committed
1100
	case 24: /* enable-reads-from-master */
1101
	  options->no_master_reads= 0;
1102
	  break;
unknown's avatar
unknown committed
1103
	case 25: /* repl-parse-query */
1104
	  options->rpl_parse= 1;
1105
	  break;
1106 1107 1108
	case 27:
	  options->max_allowed_packet= atoi(opt_arg);
	  break;
unknown's avatar
unknown committed
1109
        case 28:		/* protocol */
1110 1111 1112 1113 1114 1115
          if ((options->protocol = find_type(opt_arg, &sql_protocol_typelib,0)) == ~(ulong) 0)
          {
            fprintf(stderr, "Unknown option to protocol: %s\n", opt_arg);
            exit(1);
          }
          break;
unknown's avatar
unknown committed
1116
        case 29:		/* shared_memory_base_name */
1117 1118 1119 1120 1121
#ifdef HAVE_SMEM
          if (options->shared_memory_base_name != def_shared_memory_base_name)
            my_free(options->shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
          options->shared_memory_base_name=my_strdup(opt_arg,MYF(MY_WME));
#endif
unknown's avatar
unknown committed
1122
          break;
unknown's avatar
unknown committed
1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
	default:
	  DBUG_PRINT("warning",("unknown option: %s",option[0]));
	}
      }
    }
  }
  free_defaults(argv);
  DBUG_VOID_RETURN;
}


/***************************************************************************
1135
  Change field rows to field structs
unknown's avatar
unknown committed
1136 1137 1138 1139
***************************************************************************/

static MYSQL_FIELD *
unpack_fields(MYSQL_DATA *data,MEM_ROOT *alloc,uint fields,
1140
	      my_bool default_value, uint server_capabilities)
unknown's avatar
unknown committed
1141 1142 1143 1144 1145
{
  MYSQL_ROWS	*row;
  MYSQL_FIELD	*field,*result;
  DBUG_ENTER("unpack_fields");

unknown's avatar
unknown committed
1146 1147
  field=result=(MYSQL_FIELD*) alloc_root(alloc,
					 (uint) sizeof(MYSQL_FIELD)*fields);
unknown's avatar
unknown committed
1148
  if (!result)
1149 1150
  {
    free_rows(data);				/* Free old data */
unknown's avatar
unknown committed
1151
    DBUG_RETURN(0);
1152 1153
  }
  if (server_capabilities & CLIENT_PROTOCOL_41)
unknown's avatar
unknown committed
1154
  {
1155 1156
    /* server is 4.1, and returns the new field result format */
    for (row=data->data; row ; row = row->next,field++)
unknown's avatar
unknown committed
1157
    {
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
      field->db       = strdup_root(alloc,(char*) row->data[0]);
      field->table    = strdup_root(alloc,(char*) row->data[1]);
      field->org_table= strdup_root(alloc,(char*) row->data[2]);
      field->name     = strdup_root(alloc,(char*) row->data[3]);
      field->org_name = strdup_root(alloc,(char*) row->data[4]);
      field->length   = (uint) uint3korr(row->data[5]);
      field->type     = (enum enum_field_types) (uchar) row->data[6][0];

      field->flags=   uint2korr(row->data[7]);
      field->decimals=(uint) (uchar) row->data[7][2];

      if (INTERNAL_NUM_FIELD(field))
        field->flags|= NUM_FLAG;
      if (default_value && row->data[8])
        field->def=strdup_root(alloc,(char*) row->data[8]);
      else
        field->def=0;
      field->max_length= 0;
unknown's avatar
unknown committed
1176
    }
1177
  }
1178 1179
#ifndef DELETE_SUPPORT_OF_4_0_PROTOCOL
  else
1180
  {
1181
    /* old protocol, for backward compatibility */
1182
    for (row=data->data; row ; row = row->next,field++)
unknown's avatar
unknown committed
1183
    {
1184 1185 1186 1187
      field->org_table= field->table=  strdup_root(alloc,(char*) row->data[0]);
      field->name=   strdup_root(alloc,(char*) row->data[1]);
      field->length= (uint) uint3korr(row->data[2]);
      field->type=   (enum enum_field_types) (uchar) row->data[3][0];
unknown's avatar
unknown committed
1188

1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
      if (server_capabilities & CLIENT_LONG_FLAG)
      {
        field->flags=   uint2korr(row->data[4]);
        field->decimals=(uint) (uchar) row->data[4][2];
      }
      else
      {
        field->flags=   (uint) (uchar) row->data[4][0];
        field->decimals=(uint) (uchar) row->data[4][1];
      }
      if (INTERNAL_NUM_FIELD(field))
        field->flags|= NUM_FLAG;
      if (default_value && row->data[5])
        field->def=strdup_root(alloc,(char*) row->data[5]);
      else
        field->def=0;
      field->max_length= 0;
unknown's avatar
unknown committed
1206 1207
    }
  }
1208
#endif /* DELETE_SUPPORT_OF_4_0_PROTOCOL */
unknown's avatar
unknown committed
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
  free_rows(data);				/* Free old data */
  DBUG_RETURN(result);
}


/* Read all rows (fields or data) from server */

static MYSQL_DATA *read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
			     uint fields)
{
1219 1220
  uint	field;
  ulong pkt_len;
unknown's avatar
unknown committed
1221 1222
  ulong len;
  uchar *cp;
1223
  char	*to, *end_to;
unknown's avatar
unknown committed
1224 1225 1226 1227 1228
  MYSQL_DATA *result;
  MYSQL_ROWS **prev_ptr,*cur;
  NET *net = &mysql->net;
  DBUG_ENTER("read_rows");

unknown's avatar
unknown committed
1229
  if ((pkt_len= net_safe_read(mysql)) == packet_error)
unknown's avatar
unknown committed
1230 1231 1232 1233 1234 1235 1236 1237
    DBUG_RETURN(0);
  if (!(result=(MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
				       MYF(MY_WME | MY_ZEROFILL))))
  {
    net->last_errno=CR_OUT_OF_MEMORY;
    strmov(net->last_error,ER(net->last_errno));
    DBUG_RETURN(0);
  }
1238
  init_alloc_root(&result->alloc,8192,0);	/* Assume rowlength < 8192 */
unknown's avatar
unknown committed
1239 1240 1241 1242 1243
  result->alloc.min_malloc=sizeof(MYSQL_ROWS);
  prev_ptr= &result->data;
  result->rows=0;
  result->fields=fields;

1244 1245 1246 1247 1248 1249 1250 1251 1252
  /*
    The last EOF packet is either a single 254 character or (in MySQL 4.1)
    254 followed by 1-7 status bytes.

    This doesn't conflict with normal usage of 254 which stands for a
    string where the length of the string is 8 bytes. (see net_field_length())
  */

  while (*(cp=net->read_pos) != 254 || pkt_len >= 8)
unknown's avatar
unknown committed
1253 1254 1255
  {
    result->rows++;
    if (!(cur= (MYSQL_ROWS*) alloc_root(&result->alloc,
1256
					sizeof(MYSQL_ROWS))) ||
unknown's avatar
unknown committed
1257 1258
	!(cur->data= ((MYSQL_ROW)
		      alloc_root(&result->alloc,
1259
				 (fields+1)*sizeof(char *)+pkt_len))))
unknown's avatar
unknown committed
1260 1261 1262 1263 1264 1265 1266 1267 1268
    {
      free_rows(result);
      net->last_errno=CR_OUT_OF_MEMORY;
      strmov(net->last_error,ER(net->last_errno));
      DBUG_RETURN(0);
    }
    *prev_ptr=cur;
    prev_ptr= &cur->next;
    to= (char*) (cur->data+fields+1);
1269
    end_to=to+pkt_len-1;
unknown's avatar
unknown committed
1270 1271 1272 1273 1274 1275 1276 1277 1278
    for (field=0 ; field < fields ; field++)
    {
      if ((len=(ulong) net_field_length(&cp)) == NULL_LENGTH)
      {						/* null field */
	cur->data[field] = 0;
      }
      else
      {
	cur->data[field] = to;
1279
        if (len > (ulong) (end_to - to))
1280 1281
        {
          free_rows(result);
1282
          net->last_errno=CR_MALFORMED_PACKET;
1283 1284 1285
          strmov(net->last_error,ER(net->last_errno));
          DBUG_RETURN(0);
        }
unknown's avatar
unknown committed
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
	memcpy(to,(char*) cp,len); to[len]=0;
	to+=len+1;
	cp+=len;
	if (mysql_fields)
	{
	  if (mysql_fields[field].max_length < len)
	    mysql_fields[field].max_length=len;
	}
      }
    }
    cur->data[field]=to;			/* End of last field */
    if ((pkt_len=net_safe_read(mysql)) == packet_error)
    {
      free_rows(result);
      DBUG_RETURN(0);
    }
  }
  *prev_ptr=0;					/* last pointer is null */
1304 1305 1306 1307 1308
  if (pkt_len > 1)				/* MySQL 4.1 protocol */
  {
    mysql->warning_count= uint2korr(cp+1);
    DBUG_PRINT("info",("warning_count:  %ld", mysql->warning_count));
  }
unknown's avatar
unknown committed
1309 1310 1311 1312 1313 1314
  DBUG_PRINT("exit",("Got %d rows",result->rows));
  DBUG_RETURN(result);
}


/*
1315 1316
  Read one row. Uses packet buffer as storage for fields.
  When next packet is read, the previous field values are destroyed
unknown's avatar
unknown committed
1317 1318 1319 1320 1321 1322 1323 1324
*/


static int
read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row, ulong *lengths)
{
  uint field;
  ulong pkt_len,len;
1325
  uchar *pos,*prev_pos, *end_pos;
unknown's avatar
unknown committed
1326

1327
  if ((pkt_len=net_safe_read(mysql)) == packet_error)
unknown's avatar
unknown committed
1328
    return -1;
1329 1330 1331 1332
  if (pkt_len <= 8 && mysql->net.read_pos[0] == 254)
  {
    if (pkt_len > 1)				/* MySQL 4.1 protocol */
      mysql->warning_count= uint2korr(mysql->net.read_pos+1);
unknown's avatar
unknown committed
1333
    return 1;				/* End of data */
1334
  }
unknown's avatar
unknown committed
1335 1336
  prev_pos= 0;				/* allowed to write at packet[-1] */
  pos=mysql->net.read_pos;
1337
  end_pos=pos+pkt_len;
unknown's avatar
unknown committed
1338 1339 1340 1341 1342 1343 1344 1345 1346
  for (field=0 ; field < fields ; field++)
  {
    if ((len=(ulong) net_field_length(&pos)) == NULL_LENGTH)
    {						/* null field */
      row[field] = 0;
      *lengths++=0;
    }
    else
    {
1347
      if (len > (ulong) (end_pos - pos))
1348 1349 1350 1351 1352
      {
        mysql->net.last_errno=CR_UNKNOWN_ERROR;
        strmov(mysql->net.last_error,ER(mysql->net.last_errno));
        return -1;
      }
unknown's avatar
unknown committed
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365
      row[field] = (char*) pos;
      pos+=len;
      *lengths++=len;
    }
    if (prev_pos)
      *prev_pos=0;				/* Terminate prev field */
    prev_pos=pos;
  }
  row[field]=(char*) prev_pos+1;		/* End of last field */
  *prev_pos=0;					/* Terminate last field */
  return 0;
}

1366
/* perform query on master */
1367
my_bool STDCALL mysql_master_query(MYSQL *mysql, const char *q,
unknown's avatar
unknown committed
1368
			       unsigned long length)
1369
{
unknown's avatar
unknown committed
1370
  DBUG_ENTER("mysql_master_query");
unknown's avatar
unknown committed
1371
  if (mysql_master_send_query(mysql, q, length))
unknown's avatar
unknown committed
1372 1373
    DBUG_RETURN(1);
  DBUG_RETURN(mysql_read_query_result(mysql));
1374 1375
}

1376 1377
my_bool STDCALL mysql_master_send_query(MYSQL *mysql, const char *q,
					unsigned long length)
1378
{
unknown's avatar
unknown committed
1379 1380
  MYSQL *master = mysql->master;
  DBUG_ENTER("mysql_master_send_query");
1381
  if (!master->net.vio && !mysql_real_connect(master,0,0,0,0,0,0,0))
unknown's avatar
unknown committed
1382
    DBUG_RETURN(1);
1383
  mysql->last_used_con = master;
unknown's avatar
unknown committed
1384
  DBUG_RETURN(simple_command(master, COM_QUERY, q, length, 1));
1385 1386
}

1387

unknown's avatar
unknown committed
1388
/* perform query on slave */
1389 1390
my_bool STDCALL mysql_slave_query(MYSQL *mysql, const char *q,
				  unsigned long length)
1391
{
unknown's avatar
unknown committed
1392
  DBUG_ENTER("mysql_slave_query");
unknown's avatar
unknown committed
1393
  if (mysql_slave_send_query(mysql, q, length))
unknown's avatar
unknown committed
1394 1395
    DBUG_RETURN(1);
  DBUG_RETURN(mysql_read_query_result(mysql));
1396 1397
}

1398 1399

my_bool STDCALL mysql_slave_send_query(MYSQL *mysql, const char *q,
unknown's avatar
unknown committed
1400
				   unsigned long length)
1401 1402
{
  MYSQL* last_used_slave, *slave_to_use = 0;
unknown's avatar
unknown committed
1403
  DBUG_ENTER("mysql_slave_send_query");
unknown's avatar
unknown committed
1404

unknown's avatar
unknown committed
1405
  if ((last_used_slave = mysql->last_used_slave))
1406 1407 1408
    slave_to_use = last_used_slave->next_slave;
  else
    slave_to_use = mysql->next_slave;
unknown's avatar
unknown committed
1409 1410 1411
  /*
    Next_slave is always safe to use - we have a circular list of slaves
    if there are no slaves, mysql->next_slave == mysql
1412
  */
1413
  mysql->last_used_con = mysql->last_used_slave = slave_to_use;
unknown's avatar
unknown committed
1414
  if (!slave_to_use->net.vio && !mysql_real_connect(slave_to_use, 0,0,0,
1415
						   0,0,0,0))
unknown's avatar
unknown committed
1416 1417
    DBUG_RETURN(1);
  DBUG_RETURN(simple_command(slave_to_use, COM_QUERY, q, length, 1));
1418 1419
}

1420

1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
/* enable/disable parsing of all queries to decide
   if they go on master or slave */
void STDCALL mysql_enable_rpl_parse(MYSQL* mysql)
{
  mysql->options.rpl_parse = 1;
}

void STDCALL mysql_disable_rpl_parse(MYSQL* mysql)
{
  mysql->options.rpl_parse = 0;
}

unknown's avatar
unknown committed
1433
/* get the value of the parse flag */
1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
int STDCALL mysql_rpl_parse_enabled(MYSQL* mysql)
{
  return mysql->options.rpl_parse;
}

/*  enable/disable reads from master */
void STDCALL mysql_enable_reads_from_master(MYSQL* mysql)
{
  mysql->options.no_master_reads = 0;
}

void STDCALL mysql_disable_reads_from_master(MYSQL* mysql)
{
  mysql->options.no_master_reads = 1;
}

unknown's avatar
unknown committed
1450
/* get the value of the master read flag */
1451
my_bool STDCALL mysql_reads_from_master_enabled(MYSQL* mysql)
1452 1453 1454 1455
{
  return !(mysql->options.no_master_reads);
}

1456 1457 1458 1459 1460

/*
  We may get an error while doing replication internals.
  In this case, we add a special explanation to the original
  error
1461
*/
1462 1463

static void expand_error(MYSQL* mysql, int error)
1464 1465
{
  char tmp[MYSQL_ERRMSG_SIZE];
1466 1467 1468 1469 1470 1471
  char *p;
  uint err_length;
  strmake(tmp, mysql->net.last_error, MYSQL_ERRMSG_SIZE-1);
  p = strmake(mysql->net.last_error, ER(error), MYSQL_ERRMSG_SIZE-1);
  err_length= (uint) (p - mysql->net.last_error);
  strmake(p, tmp, MYSQL_ERRMSG_SIZE-1 - err_length);
1472 1473 1474
  mysql->net.last_errno = error;
}

1475 1476 1477
/*
  This function assumes we have just called SHOW SLAVE STATUS and have
  read the given result and row
1478
*/
1479

1480
static my_bool get_master(MYSQL* mysql, MYSQL_RES* res, MYSQL_ROW row)
1481 1482
{
  MYSQL* master;
unknown's avatar
unknown committed
1483
  DBUG_ENTER("get_master");
unknown's avatar
unknown committed
1484
  if (mysql_num_fields(res) < 3)
unknown's avatar
unknown committed
1485
    DBUG_RETURN(1); /* safety */
unknown's avatar
unknown committed
1486

1487
  /* use the same username and password as the original connection */
unknown's avatar
unknown committed
1488
  if (!(master = spawn_init(mysql, row[0], atoi(row[2]), 0, 0)))
unknown's avatar
unknown committed
1489
    DBUG_RETURN(1);
1490
  mysql->master = master;
unknown's avatar
unknown committed
1491
  DBUG_RETURN(0);
1492 1493
}

1494 1495 1496 1497

/*
  Assuming we already know that mysql points to a master connection,
  retrieve all the slaves
1498
*/
1499

1500
static my_bool get_slaves_from_master(MYSQL* mysql)
1501
{
1502 1503
  MYSQL_RES* res = 0;
  MYSQL_ROW row;
1504
  my_bool error = 1;
1505
  int has_auth_info;
unknown's avatar
unknown committed
1506
  int port_ind;
unknown's avatar
unknown committed
1507
  DBUG_ENTER("get_slaves_from_master");
unknown's avatar
unknown committed
1508

1509 1510 1511
  if (!mysql->net.vio && !mysql_real_connect(mysql,0,0,0,0,0,0,0))
  {
    expand_error(mysql, CR_PROBE_MASTER_CONNECT);
unknown's avatar
unknown committed
1512
    DBUG_RETURN(1);
1513 1514 1515
  }

  if (mysql_query(mysql, "SHOW SLAVE HOSTS") ||
1516
      !(res = mysql_store_result(mysql)))
1517 1518
  {
    expand_error(mysql, CR_PROBE_SLAVE_HOSTS);
unknown's avatar
unknown committed
1519
    DBUG_RETURN(1);
1520 1521
  }

1522
  switch (mysql_num_fields(res)) {
unknown's avatar
unknown committed
1523 1524 1525 1526 1527 1528 1529 1530
  case 5:
    has_auth_info = 0;
    port_ind=2;
    break;
  case 7:
    has_auth_info = 1;
    port_ind=4;
    break;
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
  default:
    goto err;
  }

  while ((row = mysql_fetch_row(res)))
  {
    MYSQL* slave;
    const char* tmp_user, *tmp_pass;

    if (has_auth_info)
    {
unknown's avatar
unknown committed
1542 1543
      tmp_user = row[2];
      tmp_pass = row[3];
1544 1545 1546 1547 1548 1549 1550
    }
    else
    {
      tmp_user = mysql->user;
      tmp_pass = mysql->passwd;
    }

unknown's avatar
unknown committed
1551
    if (!(slave = spawn_init(mysql, row[1], atoi(row[port_ind]),
1552 1553
			    tmp_user, tmp_pass)))
      goto err;
unknown's avatar
unknown committed
1554

1555 1556 1557 1558 1559 1560
    /* Now add slave into the circular linked list */
    slave->next_slave = mysql->next_slave;
    mysql->next_slave = slave;
  }
  error = 0;
err:
unknown's avatar
unknown committed
1561
  if (res)
1562
   mysql_free_result(res);
unknown's avatar
unknown committed
1563
  DBUG_RETURN(error);
1564 1565
}

1566

1567
my_bool STDCALL mysql_rpl_probe(MYSQL* mysql)
1568
{
unknown's avatar
unknown committed
1569
  MYSQL_RES *res= 0;
1570
  MYSQL_ROW row;
1571
  my_bool error= 1;
unknown's avatar
unknown committed
1572 1573
  DBUG_ENTER("mysql_rpl_probe");

1574 1575 1576 1577 1578
  /*
    First determine the replication role of the server we connected to
    the most reliable way to do this is to run SHOW SLAVE STATUS and see
    if we have a non-empty master host. This is still not fool-proof -
    it is not a sin to have a master that has a dormant slave thread with
unknown's avatar
unknown committed
1579
    a non-empty master host. However, it is more reliable to check
1580
    for empty master than whether the slave thread is actually running
1581
  */
1582
  if (mysql_query(mysql, "SHOW SLAVE STATUS") ||
1583
      !(res = mysql_store_result(mysql)))
1584 1585
  {
    expand_error(mysql, CR_PROBE_SLAVE_STATUS);
unknown's avatar
unknown committed
1586
    DBUG_RETURN(1);
1587
  }
unknown's avatar
unknown committed
1588

1589 1590 1591 1592 1593 1594
  row= mysql_fetch_row(res);
  /*
    Check master host for emptiness/NULL
    For MySQL 4.0 it's enough to check for row[0]
  */
  if (row && row[0] && *(row[0]))
1595 1596
  {
    /* this is a slave, ask it for the master */
1597
    if (get_master(mysql, res, row) || get_slaves_from_master(mysql))
1598 1599 1600 1601 1602
      goto err;
  }
  else
  {
    mysql->master = mysql;
1603
    if (get_slaves_from_master(mysql))
1604 1605 1606 1607 1608
      goto err;
  }

  error = 0;
err:
unknown's avatar
unknown committed
1609
  if (res)
1610
    mysql_free_result(res);
unknown's avatar
unknown committed
1611
  DBUG_RETURN(error);
1612 1613 1614
}


1615 1616 1617 1618 1619 1620 1621 1622 1623 1624
/*
  Make a not so fool-proof decision on where the query should go, to
  the master or the slave. Ideally the user should always make this
  decision himself with mysql_master_query() or mysql_slave_query().
  However, to be able to more easily port the old code, we support the
  option of an educated guess - this should work for most applications,
  however, it may make the wrong decision in some particular cases. If
  that happens, the user would have to change the code to call
  mysql_master_query() or mysql_slave_query() explicitly in the place
  where we have made the wrong decision
1625
*/
1626

1627 1628
enum mysql_rpl_type
STDCALL mysql_rpl_query_type(const char* q, int len)
1629
{
unknown's avatar
unknown committed
1630
  const char *q_end= q + len;
1631
  for (; q < q_end; ++q)
1632 1633
  {
    char c;
unknown's avatar
unknown committed
1634
    if (my_isalpha(system_charset_info, (c= *q)))
1635
    {
unknown's avatar
unknown committed
1636
      switch (my_tolower(system_charset_info,c)) {
1637 1638 1639 1640 1641 1642 1643
      case 'i':  /* insert */
      case 'u':  /* update or unlock tables */
      case 'l':  /* lock tables or load data infile */
      case 'd':  /* drop or delete */
      case 'a':  /* alter */
	return MYSQL_RPL_MASTER;
      case 'c':  /* create or check */
unknown's avatar
unknown committed
1644
	return my_tolower(system_charset_info,q[1]) == 'h' ? MYSQL_RPL_ADMIN :
unknown's avatar
unknown committed
1645
	  MYSQL_RPL_MASTER;
1646
      case 's': /* select or show */
unknown's avatar
unknown committed
1647 1648
	return my_tolower(system_charset_info,q[1]) == 'h' ? MYSQL_RPL_ADMIN :
	  MYSQL_RPL_SLAVE;
1649 1650 1651 1652 1653 1654 1655 1656
      case 'f': /* flush */
      case 'r': /* repair */
      case 'g': /* grant */
	return MYSQL_RPL_ADMIN;
      default:
	return MYSQL_RPL_SLAVE;
      }
    }
1657
  }
unknown's avatar
unknown committed
1658
  return MYSQL_RPL_MASTER;		/* By default, send to master */
1659 1660 1661
}


unknown's avatar
unknown committed
1662
/****************************************************************************
1663
  Init MySQL structure or allocate one
unknown's avatar
unknown committed
1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677
****************************************************************************/

MYSQL * STDCALL
mysql_init(MYSQL *mysql)
{
  mysql_once_init();
  if (!mysql)
  {
    if (!(mysql=(MYSQL*) my_malloc(sizeof(*mysql),MYF(MY_WME | MY_ZEROFILL))))
      return 0;
    mysql->free_me=1;
  }
  else
    bzero((char*) (mysql),sizeof(*(mysql)));
1678
  mysql->options.connect_timeout=CONNECT_TIMEOUT;
1679
  mysql->last_used_con = mysql->next_slave = mysql->master = mysql;
unknown's avatar
unknown committed
1680

1681 1682 1683
  /*
    By default, we are a replication pivot. The caller must reset it
    after we return if this is not the case.
1684
  */
unknown's avatar
unknown committed
1685
  mysql->rpl_pivot = 1;
1686
#if defined(SIGPIPE) && defined(THREAD) && !defined(__WIN__)
unknown's avatar
unknown committed
1687 1688 1689
  if (!((mysql)->client_flag & CLIENT_IGNORE_SIGPIPE))
    (void) signal(SIGPIPE,pipe_sig_handler);
#endif
1690 1691 1692

/*
  Only enable LOAD DATA INFILE by default if configured with
unknown's avatar
unknown committed
1693
  --enable-local-infile
1694 1695 1696 1697
*/
#ifdef ENABLED_LOCAL_INFILE
  mysql->options.client_flag|= CLIENT_LOCAL_FILES;
#endif
1698 1699
#ifdef HAVE_SMEM
  mysql->options.shared_memory_base_name=(char*)def_shared_memory_base_name;
unknown's avatar
unknown committed
1700
#endif
unknown's avatar
unknown committed
1701 1702 1703 1704 1705 1706 1707 1708 1709
  return mysql;
}


static void mysql_once_init()
{
  if (!mysql_client_init)
  {
    mysql_client_init=1;
1710
    org_my_init_done=my_init_done;
unknown's avatar
unknown committed
1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738
    my_init();					/* Will init threads */
    init_client_errs();
    if (!mysql_port)
    {
      mysql_port = MYSQL_PORT;
#ifndef MSDOS
      {
	struct servent *serv_ptr;
	char	*env;
	if ((serv_ptr = getservbyname("mysql", "tcp")))
	  mysql_port = (uint) ntohs((ushort) serv_ptr->s_port);
	if ((env = getenv("MYSQL_TCP_PORT")))
	  mysql_port =(uint) atoi(env);
      }
#endif
    }
    if (!mysql_unix_port)
    {
      char *env;
#ifdef __WIN__
      mysql_unix_port = (char*) MYSQL_NAMEDPIPE;
#else
      mysql_unix_port = (char*) MYSQL_UNIX_ADDR;
#endif
      if ((env = getenv("MYSQL_UNIX_PORT")))
	mysql_unix_port = env;
    }
    mysql_debug(NullS);
1739
#if defined(SIGPIPE) && !defined(THREAD) && !defined(__WIN__)
unknown's avatar
unknown committed
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
    (void) signal(SIGPIPE,SIG_IGN);
#endif
  }
#ifdef THREAD
  else
    my_thread_init();         /* Init if new thread */
#endif
}

/**************************************************************************
1750 1751
  Fill in SSL part of MYSQL structure and set 'use_ssl' flag.
  NB! Errors are not reported until you do mysql_real_connect.
unknown's avatar
unknown committed
1752 1753
**************************************************************************/

1754 1755
#define strdup_if_not_null(A) (A) == 0 ? 0 : my_strdup((A),MYF(MY_WME))

1756
my_bool STDCALL
1757
mysql_ssl_set(MYSQL *mysql __attribute__((unused)) ,
unknown's avatar
unknown committed
1758
	      const char *key __attribute__((unused)),
1759
	      const char *cert __attribute__((unused)),
unknown's avatar
unknown committed
1760
	      const char *ca __attribute__((unused)),
1761 1762
	      const char *capath __attribute__((unused)),
	      const char *cipher __attribute__((unused)))
unknown's avatar
unknown committed
1763
{
1764
#ifdef HAVE_OPENSSL
1765 1766 1767 1768 1769
  mysql->options.ssl_key=    strdup_if_not_null(key);
  mysql->options.ssl_cert=   strdup_if_not_null(cert);
  mysql->options.ssl_ca=     strdup_if_not_null(ca);
  mysql->options.ssl_capath= strdup_if_not_null(capath);
  mysql->options.ssl_cipher= strdup_if_not_null(cipher);
1770
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
1771 1772 1773
  return 0;
}

1774 1775 1776 1777 1778 1779

/**************************************************************************
  Free strings in the SSL structure and clear 'use_ssl' flag.
  NB! Errors are not reported until you do mysql_real_connect.
**************************************************************************/

unknown's avatar
unknown committed
1780
#ifdef HAVE_OPENSSL
1781
static void
unknown's avatar
unknown committed
1782
mysql_ssl_free(MYSQL *mysql __attribute__((unused)))
unknown's avatar
unknown committed
1783 1784 1785 1786 1787
{
  my_free(mysql->options.ssl_key, MYF(MY_ALLOW_ZERO_PTR));
  my_free(mysql->options.ssl_cert, MYF(MY_ALLOW_ZERO_PTR));
  my_free(mysql->options.ssl_ca, MYF(MY_ALLOW_ZERO_PTR));
  my_free(mysql->options.ssl_capath, MYF(MY_ALLOW_ZERO_PTR));
1788
  my_free(mysql->options.ssl_cipher, MYF(MY_ALLOW_ZERO_PTR));
1789
  my_free(mysql->connector_fd,MYF(MY_ALLOW_ZERO_PTR));
unknown's avatar
unknown committed
1790 1791 1792 1793
  mysql->options.ssl_key = 0;
  mysql->options.ssl_cert = 0;
  mysql->options.ssl_ca = 0;
  mysql->options.ssl_capath = 0;
1794
  mysql->options.ssl_cipher= 0;
1795
  mysql->options.use_ssl = FALSE;
unknown's avatar
unknown committed
1796
  mysql->connector_fd = 0;
1797
}
unknown's avatar
unknown committed
1798
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
1799 1800

/**************************************************************************
1801 1802
  Connect to sql server
  If host == 0 then use localhost
unknown's avatar
unknown committed
1803 1804
**************************************************************************/

1805
#ifdef USE_OLD_FUNCTIONS
unknown's avatar
unknown committed
1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
MYSQL * STDCALL
mysql_connect(MYSQL *mysql,const char *host,
	      const char *user, const char *passwd)
{
  MYSQL *res;
  mysql=mysql_init(mysql);			/* Make it thread safe */
  {
    DBUG_ENTER("mysql_connect");
    if (!(res=mysql_real_connect(mysql,host,user,passwd,NullS,0,NullS,0)))
    {
      if (mysql->free_me)
	my_free((gptr) mysql,MYF(0));
    }
    DBUG_RETURN(res);
  }
}
1822
#endif
unknown's avatar
unknown committed
1823 1824 1825


/*
1826 1827
  Note that the mysql argument must be initialized with mysql_init()
  before calling mysql_real_connect !
unknown's avatar
unknown committed
1828 1829 1830 1831 1832
*/

MYSQL * STDCALL
mysql_real_connect(MYSQL *mysql,const char *host, const char *user,
		   const char *passwd, const char *db,
1833
		   uint port, const char *unix_socket,ulong client_flag)
unknown's avatar
unknown committed
1834
{
1835 1836
  char		buff[NAME_LEN+USERNAME_LENGTH+100],charset_name_buff[16];
  char		*end,*host_info,*charset_name;
unknown's avatar
unknown committed
1837
  char          password_hash[SCRAMBLE41_LENGTH]; /* tmp storage stage1 hash */
unknown's avatar
unknown committed
1838
  my_socket	sock;
unknown's avatar
unknown committed
1839 1840
  uint32	ip_addr;
  struct	sockaddr_in sock_addr;
1841
  ulong		pkt_length;
unknown's avatar
unknown committed
1842 1843 1844 1845 1846 1847 1848 1849 1850
  NET		*net= &mysql->net;
#ifdef __WIN__
  HANDLE	hPipe=INVALID_HANDLE_VALUE;
#endif
#ifdef HAVE_SYS_UN_H
  struct	sockaddr_un UNIXaddr;
#endif
  init_sigpipe_variables
  DBUG_ENTER("mysql_real_connect");
unknown's avatar
unknown committed
1851
  LINT_INIT(host_info);
unknown's avatar
unknown committed
1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898

  DBUG_PRINT("enter",("host: %s  db: %s  user: %s",
		      host ? host : "(Null)",
		      db ? db : "(Null)",
		      user ? user : "(Null)"));

  /* Don't give sigpipe errors if the client doesn't want them */
  set_sigpipe(mysql);
  net->vio = 0;				/* If something goes wrong */
  /* use default options */
  if (mysql->options.my_cnf_file || mysql->options.my_cnf_group)
  {
    mysql_read_default_options(&mysql->options,
			       (mysql->options.my_cnf_file ?
				mysql->options.my_cnf_file : "my"),
			       mysql->options.my_cnf_group);
    my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
    mysql->options.my_cnf_file=mysql->options.my_cnf_group=0;
  }

  /* Some empty-string-tests are done because of ODBC */
  if (!host || !host[0])
    host=mysql->options.host;
  if (!user || !user[0])
    user=mysql->options.user;
  if (!passwd)
  {
    passwd=mysql->options.password;
#ifndef DONT_USE_MYSQL_PWD
    if (!passwd)
      passwd=getenv("MYSQL_PWD");  /* get it from environment (haneke) */
#endif
  }
  if (!db || !db[0])
    db=mysql->options.db;
  if (!port)
    port=mysql->options.port;
  if (!unix_socket)
    unix_socket=mysql->options.unix_socket;

  mysql->reconnect=1;			/* Reconnect as default */
  mysql->server_status=SERVER_STATUS_AUTOCOMMIT;

  /*
  ** Grab a socket and connect it to the server
  */
1899 1900 1901 1902
#if defined(HAVE_SMEM)
  if ((!mysql->options.protocol || mysql->options.protocol == MYSQL_PROTOCOL_MEMORY)&&
      (!host || !strcmp(host,LOCAL_HOST)))
  {
unknown's avatar
unknown committed
1903
    if ((create_shared_memory(mysql,net, mysql->options.connect_timeout)) ==
1904
	INVALID_HANDLE_VALUE)
1905 1906 1907 1908 1909 1910 1911 1912
    {
      DBUG_PRINT("error",
        ("host: '%s'  socket: '%s'  shared memory: %s  have_tcpip: %d",
          host ? host : "<null>",
          unix_socket ? unix_socket : "<null>",
          (int) mysql->options.shared_memory_base_name,
          (int) have_tcpip));
	  if (mysql->options.protocol == MYSQL_PROTOCOL_MEMORY)
unknown's avatar
unknown committed
1913 1914
	    goto error;
/*
1915 1916
Try also with PIPE or TCP/IP
*/
unknown's avatar
unknown committed
1917
    }
1918 1919 1920 1921 1922 1923 1924 1925 1926 1927
    else
    {
      mysql->options.protocol=MYSQL_PROTOCOL_MEMORY;
      sock=0;
      unix_socket = 0;
      host=mysql->options.shared_memory_base_name;
      host_info=(char*) ER(CR_SHARED_MEMORY_CONNECTION);
    }
  } else
#endif //HAVE_SMEM
unknown's avatar
unknown committed
1928
#if defined(HAVE_SYS_UN_H)
1929 1930
  if ((!mysql->options.protocol || mysql->options.protocol == MYSQL_PROTOCOL_SOCKET)&&
     (!host || !strcmp(host,LOCAL_HOST)) && (unix_socket || mysql_unix_port))
unknown's avatar
unknown committed
1931 1932 1933 1934 1935 1936 1937 1938 1939
  {
    host=LOCAL_HOST;
    if (!unix_socket)
      unix_socket=mysql_unix_port;
    host_info=(char*) ER(CR_LOCALHOST_CONNECTION);
    DBUG_PRINT("info",("Using UNIX sock '%s'",unix_socket));
    if ((sock = socket(AF_UNIX,SOCK_STREAM,0)) == SOCKET_ERROR)
    {
      net->last_errno=CR_SOCKET_CREATE_ERROR;
unknown's avatar
unknown committed
1940
      sprintf(net->last_error,ER(net->last_errno),socket_errno);
unknown's avatar
unknown committed
1941 1942 1943 1944 1945 1946
      goto error;
    }
    net->vio = vio_new(sock, VIO_TYPE_SOCKET, TRUE);
    bzero((char*) &UNIXaddr,sizeof(UNIXaddr));
    UNIXaddr.sun_family = AF_UNIX;
    strmov(UNIXaddr.sun_path, unix_socket);
unknown's avatar
unknown committed
1947
    if (my_connect(sock,(struct sockaddr *) &UNIXaddr, sizeof(UNIXaddr),
1948
		   mysql->options.connect_timeout))
unknown's avatar
unknown committed
1949
    {
unknown's avatar
unknown committed
1950
      DBUG_PRINT("error",("Got error %d on connect to local server",socket_errno));
unknown's avatar
unknown committed
1951
      net->last_errno=CR_CONNECTION_ERROR;
unknown's avatar
unknown committed
1952
      sprintf(net->last_error,ER(net->last_errno),unix_socket,socket_errno);
unknown's avatar
unknown committed
1953 1954
      goto error;
    }
1955 1956
    else
      mysql->options.protocol=MYSQL_PROTOCOL_SOCKET;
unknown's avatar
unknown committed
1957 1958 1959
  }
  else
#elif defined(__WIN__)
1960 1961 1962 1963 1964 1965 1966 1967
  if ((!mysql->options.protocol || mysql->options.protocol == MYSQL_PROTOCOL_PIPE)&&
      ((unix_socket || !host && is_NT() ||
	host && !strcmp(host,LOCAL_HOST_NAMEDPIPE) ||!have_tcpip))&&(!net->vio))
  {
    sock=0;
    if ((hPipe=create_named_pipe(net, mysql->options.connect_timeout,
		   (char**) &host, (char**) &unix_socket)) ==
                    INVALID_HANDLE_VALUE)
unknown's avatar
unknown committed
1968
    {
1969 1970 1971 1972 1973 1974 1975 1976
      DBUG_PRINT("error",
                ("host: '%s'  socket: '%s'  have_tcpip: %d",
                host ? host : "<null>",
                unix_socket ? unix_socket : "<null>",
                (int) have_tcpip));
      if (mysql->options.protocol == MYSQL_PROTOCOL_PIPE ||
          (host && !strcmp(host,LOCAL_HOST_NAMEDPIPE)) ||
          (unix_socket && !strcmp(unix_socket,MYSQL_NAMEDPIPE)))
unknown's avatar
unknown committed
1977 1978 1979
            goto error;
	    /*
            Try also with TCP/IP
1980 1981 1982 1983 1984 1985 1986
            */
    }
    else
    {
      net->vio=vio_new_win32pipe(hPipe);
      sprintf(host_info=buff, ER(CR_NAMEDPIPE_CONNECTION), host,
        unix_socket);
unknown's avatar
unknown committed
1987 1988 1989
    }
  }
#endif
1990
  if ((!mysql->options.protocol || mysql->options.protocol == MYSQL_PROTOCOL_TCP)&&(!net->vio))
unknown's avatar
unknown committed
1991 1992 1993 1994 1995 1996 1997 1998
  {
    unix_socket=0;				/* This is not used */
    if (!port)
      port=mysql_port;
    if (!host)
      host=LOCAL_HOST;
    sprintf(host_info=buff,ER(CR_TCP_CONNECTION),host);
    DBUG_PRINT("info",("Server name: '%s'.  TCP sock: %d", host,port));
unknown's avatar
unknown committed
1999
    /* _WIN64 ;  Assume that the (int) range is enough for socket() */
unknown's avatar
unknown committed
2000
    if ((sock = (my_socket) socket(AF_INET,SOCK_STREAM,0)) == SOCKET_ERROR)
unknown's avatar
unknown committed
2001 2002
    {
      net->last_errno=CR_IPSOCK_ERROR;
unknown's avatar
unknown committed
2003
      sprintf(net->last_error,ER(net->last_errno),socket_errno);
unknown's avatar
unknown committed
2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
      goto error;
    }
    net->vio = vio_new(sock,VIO_TYPE_TCPIP,FALSE);
    bzero((char*) &sock_addr,sizeof(sock_addr));
    sock_addr.sin_family = AF_INET;

    /*
    ** The server name may be a host name or IP address
    */

    if ((int) (ip_addr = inet_addr(host)) != (int) INADDR_NONE)
    {
      memcpy_fixed(&sock_addr.sin_addr,&ip_addr,sizeof(ip_addr));
    }
    else
    {
      int tmp_errno;
      struct hostent tmp_hostent,*hp;
      char buff2[GETHOSTBYNAME_BUFF_SIZE];
      hp = my_gethostbyname_r(host,&tmp_hostent,buff2,sizeof(buff2),
			      &tmp_errno);
      if (!hp)
      {
2027
	my_gethostbyname_r_free();
unknown's avatar
unknown committed
2028 2029 2030 2031 2032
	net->last_errno=CR_UNKNOWN_HOST;
	sprintf(net->last_error, ER(CR_UNKNOWN_HOST), host, tmp_errno);
	goto error;
      }
      memcpy(&sock_addr.sin_addr,hp->h_addr, (size_t) hp->h_length);
unknown's avatar
unknown committed
2033
      my_gethostbyname_r_free();
unknown's avatar
unknown committed
2034 2035
    }
    sock_addr.sin_port = (ushort) htons((ushort) port);
unknown's avatar
unknown committed
2036
    if (my_connect(sock,(struct sockaddr *) &sock_addr, sizeof(sock_addr),
unknown's avatar
unknown committed
2037 2038
		 mysql->options.connect_timeout) <0)
    {
unknown's avatar
unknown committed
2039
      DBUG_PRINT("error",("Got error %d on connect to '%s'",socket_errno,host));
unknown's avatar
unknown committed
2040
      net->last_errno= CR_CONN_HOST_ERROR;
unknown's avatar
unknown committed
2041
      sprintf(net->last_error ,ER(CR_CONN_HOST_ERROR), host, socket_errno);
unknown's avatar
unknown committed
2042 2043 2044
      goto error;
    }
  }
2045 2046 2047 2048 2049 2050 2051 2052
  else
    if (!net->vio)
    {
      DBUG_PRINT("error",("Unknow protocol %d ",mysql->options.protocol));
      net->last_errno= CR_CONN_UNKNOW_PROTOCOL;
      sprintf(net->last_error ,ER(CR_CONN_UNKNOW_PROTOCOL));
      goto error;
    };
unknown's avatar
unknown committed
2053 2054 2055 2056

  if (!net->vio || my_net_init(net, net->vio))
  {
    vio_delete(net->vio);
unknown's avatar
unknown committed
2057
    net->vio = 0;
unknown's avatar
unknown committed
2058 2059 2060 2061 2062 2063 2064 2065
    net->last_errno=CR_OUT_OF_MEMORY;
    strmov(net->last_error,ER(net->last_errno));
    goto error;
  }
  vio_keepalive(net->vio,TRUE);

  /* Get version info */
  mysql->protocol_version= PROTOCOL_VERSION;	/* Assume this */
2066 2067 2068 2069
  if (mysql->options.connect_timeout &&
      vio_poll_read(net->vio, mysql->options.connect_timeout))
  {
    net->last_errno= CR_SERVER_LOST;
unknown's avatar
unknown committed
2070
    strmov(net->last_error,ER(net->last_errno));
2071 2072
    goto error;
  }
unknown's avatar
unknown committed
2073 2074 2075
  if ((pkt_length=net_safe_read(mysql)) == packet_error)
    goto error;

2076
  /* Check if version of protocol matches current one */
unknown's avatar
unknown committed
2077 2078 2079 2080 2081

  mysql->protocol_version= net->read_pos[0];
  DBUG_DUMP("packet",(char*) net->read_pos,10);
  DBUG_PRINT("info",("mysql protocol version %d, server=%d",
		     PROTOCOL_VERSION, mysql->protocol_version));
2082
  if (mysql->protocol_version != PROTOCOL_VERSION)
unknown's avatar
unknown committed
2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
  {
    net->last_errno= CR_VERSION_ERROR;
    sprintf(net->last_error, ER(CR_VERSION_ERROR), mysql->protocol_version,
	    PROTOCOL_VERSION);
    goto error;
  }
  end=strend((char*) net->read_pos+1);
  mysql->thread_id=uint4korr(end+1);
  end+=5;
  strmake(mysql->scramble_buff,end,8);
  end+=9;
  if (pkt_length >= (uint) (end+1 - (char*) net->read_pos))
    mysql->server_capabilities=uint2korr(end);
  if (pkt_length >= (uint) (end+18 - (char*) net->read_pos))
  {
    /* New protocol with 16 bytes to describe server characteristics */
    mysql->server_language=end[2];
    mysql->server_status=uint2korr(end+3);
  }

  /* Set character set */
  if ((charset_name=mysql->options.charset_name))
  {
    const char *save=charsets_dir;
    if (mysql->options.charset_dir)
      charsets_dir=mysql->options.charset_dir;
    mysql->charset=get_charset_by_name(mysql->options.charset_name,
                                       MYF(MY_WME));
    charsets_dir=save;
  }
  else if (mysql->server_language)
  {
    charset_name=charset_name_buff;
    sprintf(charset_name,"%d",mysql->server_language);	/* In case of errors */
2117
    if (!(mysql->charset =
2118
	  get_charset((uint8) mysql->server_language, MYF(0))))
2119 2120
      mysql->charset = default_charset_info; /* shouldn't be fatal */

unknown's avatar
unknown committed
2121 2122 2123 2124 2125 2126 2127
  }
  else
    mysql->charset=default_charset_info;

  if (!mysql->charset)
  {
    net->last_errno=CR_CANT_READ_CHARSET;
2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
    if (mysql->options.charset_dir)
      sprintf(net->last_error,ER(net->last_errno),
              charset_name ? charset_name : "unknown",
              mysql->options.charset_dir);
    else
    {
      char cs_dir_name[FN_REFLEN];
      get_charsets_dir(cs_dir_name);
      sprintf(net->last_error,ER(net->last_errno),
              charset_name ? charset_name : "unknown",
              cs_dir_name);
    }
unknown's avatar
unknown committed
2140 2141
    goto error;
  }
unknown's avatar
unknown committed
2142

unknown's avatar
unknown committed
2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167
  /* Save connection information */
  if (!user) user="";
  if (!passwd) passwd="";
  if (!my_multi_malloc(MYF(0),
		       &mysql->host_info, (uint) strlen(host_info)+1,
		       &mysql->host,      (uint) strlen(host)+1,
		       &mysql->unix_socket,unix_socket ?
		       (uint) strlen(unix_socket)+1 : (uint) 1,
		       &mysql->server_version,
		       (uint) (end - (char*) net->read_pos),
		       NullS) ||
      !(mysql->user=my_strdup(user,MYF(0))) ||
      !(mysql->passwd=my_strdup(passwd,MYF(0))))
  {
    strmov(net->last_error, ER(net->last_errno=CR_OUT_OF_MEMORY));
    goto error;
  }
  strmov(mysql->host_info,host_info);
  strmov(mysql->host,host);
  if (unix_socket)
    strmov(mysql->unix_socket,unix_socket);
  else
    mysql->unix_socket=0;
  strmov(mysql->server_version,(char*) net->read_pos+1);
  mysql->port=port;
2168
  client_flag|=mysql->options.client_flag;
unknown's avatar
unknown committed
2169 2170 2171 2172 2173

  /* Send client information for access check */
  client_flag|=CLIENT_CAPABILITIES;

#ifdef HAVE_OPENSSL
unknown's avatar
unknown committed
2174 2175 2176 2177
  if (mysql->options.ssl_key || mysql->options.ssl_cert ||
      mysql->options.ssl_ca || mysql->options.ssl_capath ||
      mysql->options.ssl_cipher)
    mysql->options.use_ssl= 1;
unknown's avatar
unknown committed
2178 2179 2180 2181 2182
  if (mysql->options.use_ssl)
    client_flag|=CLIENT_SSL;
#endif /* HAVE_OPENSSL */
  if (db)
    client_flag|=CLIENT_CONNECT_WITH_DB;
2183 2184 2185 2186 2187 2188 2189
  /* Remove options that server doesn't support */
  client_flag= ((client_flag &
		~(CLIENT_COMPRESS | CLIENT_SSL | CLIENT_PROTOCOL_41)) |
		(client_flag & mysql->server_capabilities));

#ifndef HAVE_COMPRESS
  client_flag&= ~CLIENT_COMPRESS;
unknown's avatar
unknown committed
2190 2191
#endif

2192
  if (client_flag & CLIENT_PROTOCOL_41)
unknown's avatar
unknown committed
2193
  {
2194 2195 2196 2197
    /* 4.1 server and 4.1 client has a 4 byte option flag */
    int4store(buff,client_flag);
    int4store(buff+4,max_allowed_packet);
    end= buff+8;
unknown's avatar
unknown committed
2198 2199 2200
  }
  else
  {
2201 2202 2203
    int2store(buff,client_flag);
    int3store(buff+2,max_allowed_packet);
    end= buff+5;
unknown's avatar
unknown committed
2204 2205 2206 2207
  }
  mysql->client_flag=client_flag;

#ifdef HAVE_OPENSSL
2208 2209 2210 2211
  /*
    Oops.. are we careful enough to not send ANY information without
    encryption?
  */
unknown's avatar
unknown committed
2212 2213
  if (client_flag & CLIENT_SSL)
  {
2214
    struct st_mysql_options *options= &mysql->options;
2215
    if (my_net_write(net,buff,(uint) (end-buff)) || net_flush(net))
2216 2217
    {
      net->last_errno= CR_SERVER_LOST;
unknown's avatar
unknown committed
2218
      strmov(net->last_error,ER(net->last_errno));
unknown's avatar
unknown committed
2219
      goto error;
2220
    }
unknown's avatar
unknown committed
2221
    /* Do the SSL layering. */
2222 2223 2224 2225 2226 2227 2228
    if (!(mysql->connector_fd=
	  (gptr) new_VioSSLConnectorFd(options->ssl_key,
				       options->ssl_cert,
				       options->ssl_ca,
				       options->ssl_capath,
				       options->ssl_cipher)))
    {
unknown's avatar
unknown committed
2229
      net->last_errno= CR_SSL_CONNECTION_ERROR;
unknown's avatar
unknown committed
2230
      strmov(net->last_error,ER(net->last_errno));
2231 2232
      goto error;
    }
unknown's avatar
unknown committed
2233
    DBUG_PRINT("info", ("IO layer change in progress..."));
2234 2235
    if (sslconnect((struct st_VioSSLConnectorFd*)(mysql->connector_fd),
		   mysql->net.vio, (long) (mysql->options.connect_timeout)))
unknown's avatar
unknown committed
2236 2237 2238
    {
      net->last_errno= CR_SSL_CONNECTION_ERROR;
      strmov(net->last_error,ER(net->last_errno));
unknown's avatar
unknown committed
2239
      goto error;
unknown's avatar
unknown committed
2240
    }
unknown's avatar
unknown committed
2241
    DBUG_PRINT("info", ("IO layer change done!"));
unknown's avatar
unknown committed
2242 2243 2244
  }
#endif /* HAVE_OPENSSL */

2245
  DBUG_PRINT("info",("Server version = '%s'  capabilites: %lu  status: %u  client_flag: %lu",
2246 2247
		     mysql->server_version,mysql->server_capabilities,
		     mysql->server_status, client_flag));
2248
  /* This needs to be changed as it's not useful with big packets */
unknown's avatar
unknown committed
2249
  if (user && user[0])
2250
    strmake(end,user,32);			/* Max user name */
unknown's avatar
unknown committed
2251
  else
2252
    read_user_name((char*) end);
unknown's avatar
unknown committed
2253
  /* We have to handle different version of handshake here */
unknown's avatar
unknown committed
2254 2255 2256
#ifdef _CUSTOMCONFIG_
#include "_cust_libmysql.h";
#endif
2257
  DBUG_PRINT("info",("user: %s",end));
unknown's avatar
unknown committed
2258
  /*
2259 2260 2261 2262 2263 2264 2265
    We always start with old type handshake the only difference is message sent
    If server handles secure connection type we'll not send the real scramble
   */
  if (mysql->server_capabilities & CLIENT_SECURE_CONNECTION)
  {
    if (passwd[0])
    {
2266
      /* Prepare false scramble  */
2267
      end=strend(end)+1;
2268 2269 2270
      bfill(end, SCRAMBLE_LENGTH, 'x');
      end+=SCRAMBLE_LENGTH;
      *end=0;
unknown's avatar
unknown committed
2271
    }
unknown's avatar
unknown committed
2272
    else  /* For empty password*/
2273
    {
2274
      end=strend(end)+1;
2275 2276 2277 2278
      *end=0; /* Store zero length scramble */
    }
  }
  else
2279
  {
2280 2281 2282 2283
    /*
     Real scramble is only sent to old servers. This can be blocked 
     by calling mysql_options(MYSQL *, MYSQL_SECURE_CONNECT, (char*) &1);
    */
2284
    end=scramble(strend(end)+1, mysql->scramble_buff, passwd,
2285
                 (my_bool) (mysql->protocol_version == 9));
2286
  }
unknown's avatar
unknown committed
2287
  /* Add database if needed */
unknown's avatar
unknown committed
2288 2289
  if (db && (mysql->server_capabilities & CLIENT_CONNECT_WITH_DB))
  {
unknown's avatar
unknown committed
2290
    end=strmake(end+1,db,NAME_LEN);
unknown's avatar
unknown committed
2291 2292 2293
    mysql->db=my_strdup(db,MYF(MY_WME));
    db=0;
  }
unknown's avatar
unknown committed
2294
  /* Write authentication package */
2295 2296
  if (my_net_write(net,buff,(ulong) (end-buff)) || net_flush(net))
  {
unknown's avatar
unknown committed
2297 2298
    net->last_errno= CR_SERVER_LOST;
    strmov(net->last_error,ER(net->last_errno));
2299 2300
    goto error;
  }
unknown's avatar
unknown committed
2301 2302 2303

  /* We shall only query sever if it expect us to do so */

2304
  if ( (pkt_length=net_safe_read(mysql)) == packet_error)
unknown's avatar
unknown committed
2305
    goto error;
2306 2307 2308

  if  (mysql->server_capabilities & CLIENT_SECURE_CONNECTION)
  {
2309 2310 2311
    /* This should always happen with new server unless empty password */
    if (pkt_length==24 && net->read_pos[0]) 
    /* OK/Error packets have zero as the first char */
2312
    {
2313 2314
      /* Old passwords will have '*' at the first byte of hash */
      if (net->read_pos[0] != '*')
2315
      {
unknown's avatar
unknown committed
2316 2317
        /* Build full password hash as it is required to decode scramble */
        password_hash_stage1(buff, passwd);
2318
        /* Store copy as we'll need it later */
unknown's avatar
unknown committed
2319
        memcpy(password_hash,buff,SCRAMBLE41_LENGTH);
2320
        /* Finally hash complete password using hash we got from server */
unknown's avatar
unknown committed
2321
        password_hash_stage2(password_hash,(const char*) net->read_pos);
2322
        /* Decypt and store scramble 4 = hash for stage2 */
unknown's avatar
unknown committed
2323 2324
        password_crypt((const char*) net->read_pos+4,mysql->scramble_buff,
		       password_hash, SCRAMBLE41_LENGTH);
unknown's avatar
unknown committed
2325
        mysql->scramble_buff[SCRAMBLE41_LENGTH]=0;
2326
        /* Encode scramble with password. Recycle buffer */
unknown's avatar
unknown committed
2327
        password_crypt(mysql->scramble_buff,buff,buff,SCRAMBLE41_LENGTH);
2328 2329 2330 2331 2332 2333
      }
      else
      {
       /* Create password to decode scramble */
       create_key_from_old_password(passwd,password_hash);
       /* Decypt and store scramble 4 = hash for stage2 */
unknown's avatar
unknown committed
2334 2335
       password_crypt((const char*) net->read_pos+4,mysql->scramble_buff,
		      password_hash, SCRAMBLE41_LENGTH);
unknown's avatar
unknown committed
2336 2337 2338 2339
       mysql->scramble_buff[SCRAMBLE41_LENGTH]=0;
       /* Finally scramble decoded scramble with password */
       scramble(buff, mysql->scramble_buff, passwd,0);
      }
2340
      /* Write second package of authentication */
unknown's avatar
unknown committed
2341
      if (my_net_write(net,buff,SCRAMBLE41_LENGTH) || net_flush(net))
2342
      {
unknown's avatar
unknown committed
2343 2344
        net->last_errno= CR_SERVER_LOST;
        strmov(net->last_error,ER(net->last_errno));
2345 2346
        goto error;
      }
unknown's avatar
unknown committed
2347
      /* Read What server thinks about out new auth message report */
2348 2349 2350 2351
      if (net_safe_read(mysql) == packet_error)
          goto error;
    }
  }
unknown's avatar
unknown committed
2352 2353 2354

    /* End of authentication part of handshake */

unknown's avatar
unknown committed
2355 2356
  if (client_flag & CLIENT_COMPRESS)		/* We will use compression */
    net->compress=1;
2357 2358
  if (mysql->options.max_allowed_packet)
    net->max_packet_size= mysql->options.max_allowed_packet;
unknown's avatar
unknown committed
2359 2360
  if (db && mysql_select_db(mysql,db))
    goto error;
unknown's avatar
unknown committed
2361 2362

  if (mysql->options.init_commands)
unknown's avatar
unknown committed
2363
  {
unknown's avatar
unknown committed
2364 2365 2366 2367
    DYNAMIC_ARRAY *init_commands= mysql->options.init_commands;
    char **ptr= (char**)init_commands->buffer;
    char **end= ptr + init_commands->elements;

unknown's avatar
unknown committed
2368 2369
    my_bool reconnect=mysql->reconnect;
    mysql->reconnect=0;
unknown's avatar
unknown committed
2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383

    for (; ptr<end; ptr++)
    {
      MYSQL_RES *res;
      if (mysql_query(mysql,*ptr))
	goto error;
      if (mysql->fields)
      {
	if (!(res= mysql_use_result(mysql)))
	  goto error;
	mysql_free_result(res);
      }
    }

unknown's avatar
unknown committed
2384 2385 2386
    mysql->reconnect=reconnect;
  }

2387 2388
  if (mysql->options.rpl_probe && mysql_rpl_probe(mysql))
    goto error;
unknown's avatar
unknown committed
2389

unknown's avatar
unknown committed
2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407
  DBUG_PRINT("exit",("Mysql handler: %lx",mysql));
  reset_sigpipe(mysql);
  DBUG_RETURN(mysql);

error:
  reset_sigpipe(mysql);
  DBUG_PRINT("error",("message: %u (%s)",net->last_errno,net->last_error));
  {
    /* Free alloced memory */
    my_bool free_me=mysql->free_me;
    end_server(mysql);
    mysql->free_me=0;
    mysql_close(mysql);
    mysql->free_me=free_me;
  }
  DBUG_RETURN(0);
}

2408

2409
/* needed when we move MYSQL structure to a different address */
2410

2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426
static void mysql_fix_pointers(MYSQL* mysql, MYSQL* old_mysql)
{
  MYSQL *tmp, *tmp_prev;
  if (mysql->master == old_mysql)
    mysql->master = mysql;
  if (mysql->last_used_con == old_mysql)
    mysql->last_used_con = mysql;
  if (mysql->last_used_slave == old_mysql)
    mysql->last_used_slave = mysql;
  for (tmp_prev = mysql, tmp = mysql->next_slave;
       tmp != old_mysql;tmp = tmp->next_slave)
  {
    tmp_prev = tmp;
  }
  tmp_prev->next_slave = mysql;
}
unknown's avatar
unknown committed
2427

2428

unknown's avatar
unknown committed
2429 2430 2431 2432 2433 2434 2435 2436
static my_bool mysql_reconnect(MYSQL *mysql)
{
  MYSQL tmp_mysql;
  DBUG_ENTER("mysql_reconnect");

  if (!mysql->reconnect ||
      (mysql->server_status & SERVER_STATUS_IN_TRANS) || !mysql->host_info)
  {
2437
   /* Allow reconnect next time */
unknown's avatar
unknown committed
2438
    mysql->server_status&= ~SERVER_STATUS_IN_TRANS;
2439 2440
    mysql->net.last_errno=CR_SERVER_GONE_ERROR;
    strmov(mysql->net.last_error,ER(mysql->net.last_errno));
unknown's avatar
unknown committed
2441 2442 2443 2444
    DBUG_RETURN(1);
  }
  mysql_init(&tmp_mysql);
  tmp_mysql.options=mysql->options;
2445
  bzero((char*) &mysql->options,sizeof(mysql->options));
2446
  tmp_mysql.rpl_pivot = mysql->rpl_pivot;
unknown's avatar
unknown committed
2447 2448 2449
  if (!mysql_real_connect(&tmp_mysql,mysql->host,mysql->user,mysql->passwd,
			  mysql->db, mysql->port, mysql->unix_socket,
			  mysql->client_flag))
unknown's avatar
unknown committed
2450 2451 2452
  {
    mysql->net.last_errno= tmp_mysql.net.last_errno;
    strmov(mysql->net.last_error, tmp_mysql.net.last_error);
unknown's avatar
unknown committed
2453
    DBUG_RETURN(1);
unknown's avatar
unknown committed
2454
  }
unknown's avatar
unknown committed
2455 2456 2457 2458
  tmp_mysql.free_me=mysql->free_me;
  mysql->free_me=0;
  mysql_close(mysql);
  *mysql=tmp_mysql;
unknown's avatar
unknown committed
2459
  mysql_fix_pointers(mysql, &tmp_mysql); /* adjust connection pointers */
unknown's avatar
unknown committed
2460 2461 2462 2463 2464 2465 2466
  net_clear(&mysql->net);
  mysql->affected_rows= ~(my_ulonglong) 0;
  DBUG_RETURN(0);
}


/**************************************************************************
unknown's avatar
unknown committed
2467
  Change user and database
unknown's avatar
unknown committed
2468 2469
**************************************************************************/

unknown's avatar
unknown committed
2470
my_bool	STDCALL mysql_change_user(MYSQL *mysql, const char *user,
unknown's avatar
unknown committed
2471 2472
				  const char *passwd, const char *db)
{
unknown's avatar
unknown committed
2473 2474
  char buff[512],*end=buff;
  ulong		pkt_length;
unknown's avatar
unknown committed
2475
  char          password_hash[SCRAMBLE41_LENGTH]; /* Used for tmp storage of stage1 hash */
unknown's avatar
unknown committed
2476
  NET		*net= &mysql->net;
unknown's avatar
unknown committed
2477

unknown's avatar
unknown committed
2478 2479 2480 2481 2482 2483
  DBUG_ENTER("mysql_change_user");

  if (!user)
    user="";
  if (!passwd)
    passwd="";
unknown's avatar
unknown committed
2484

unknown's avatar
unknown committed
2485 2486
   /* Store user into the buffer */
  end=strmov(end,user)+1;
unknown's avatar
unknown committed
2487 2488

  /*
unknown's avatar
unknown committed
2489 2490 2491 2492 2493 2494 2495
    We always start with old type handshake the only difference is message sent
    If server handles secure connection type we'll not send the real scramble
  */
  if (mysql->server_capabilities & CLIENT_SECURE_CONNECTION)
  {
    if (passwd[0])
    {
2496 2497 2498 2499 2500
      /* Prepare false scramble  */
      bfill(end, SCRAMBLE_LENGTH, 'x');
      end+=SCRAMBLE_LENGTH;
      *end=0;

unknown's avatar
unknown committed
2501 2502
    }
    else  /* For empty password*/
unknown's avatar
unknown committed
2503 2504 2505
      *end=0; /* Store zero length scramble */
  }
  else
2506 2507 2508 2509
   /*
    Real scramble is only sent to old servers. This can be blocked 
    by calling mysql_options(MYSQL *, MYSQL_SECURE_CONNECT, (char*) &1);
   */
unknown's avatar
unknown committed
2510 2511
    end=scramble(end, mysql->scramble_buff, passwd,
                 (my_bool) (mysql->protocol_version == 9));
unknown's avatar
unknown committed
2512 2513

  /* Add database if needed */
unknown's avatar
unknown committed
2514
  end=strmov(end+1,db ? db : "");
unknown's avatar
unknown committed
2515 2516 2517

  /* Write authentication package */

unknown's avatar
unknown committed
2518
  simple_command(mysql,COM_CHANGE_USER, buff,(ulong) (end-buff),1);
unknown's avatar
unknown committed
2519 2520

  /* We shall only query sever if it expect us to do so */
unknown's avatar
unknown committed
2521 2522
  if ( (pkt_length=net_safe_read(mysql)) == packet_error)
    goto error;
unknown's avatar
unknown committed
2523

unknown's avatar
unknown committed
2524 2525
  if  (mysql->server_capabilities & CLIENT_SECURE_CONNECTION)
  {
2526 2527 2528
    /* This should always happen with new server unless empty password */
    if (pkt_length==24 && net->read_pos[0])
    /* Err/OK messages has first character=0 */
unknown's avatar
unknown committed
2529 2530
    {
      /* Old passwords will have zero at the first byte of hash */
2531
      if (net->read_pos[0] != '*')
unknown's avatar
unknown committed
2532
      {
unknown's avatar
unknown committed
2533 2534
        /* Build full password hash as it is required to decode scramble */
        password_hash_stage1(buff, passwd);
unknown's avatar
unknown committed
2535
        /* Store copy as we'll need it later */
unknown's avatar
unknown committed
2536
        memcpy(password_hash,buff,SCRAMBLE41_LENGTH);
unknown's avatar
unknown committed
2537
        /* Finally hash complete password using hash we got from server */
unknown's avatar
unknown committed
2538
        password_hash_stage2(password_hash, (const char*) net->read_pos);
unknown's avatar
unknown committed
2539
        /* Decypt and store scramble 4 = hash for stage2 */
unknown's avatar
unknown committed
2540 2541
        password_crypt((const char*) net->read_pos+4, mysql->scramble_buff,
		       password_hash, SCRAMBLE41_LENGTH);
unknown's avatar
unknown committed
2542
        mysql->scramble_buff[SCRAMBLE41_LENGTH]=0;
unknown's avatar
unknown committed
2543
        /* Encode scramble with password. Recycle buffer */
unknown's avatar
unknown committed
2544
        password_crypt(mysql->scramble_buff,buff,buff,SCRAMBLE41_LENGTH);
unknown's avatar
unknown committed
2545 2546 2547 2548 2549 2550
      }
      else
      {
        /* Create password to decode scramble */
        create_key_from_old_password(passwd,password_hash);
        /* Decypt and store scramble 4 = hash for stage2 */
unknown's avatar
unknown committed
2551 2552
        password_crypt((const char*) net->read_pos+4,mysql->scramble_buff,
		       password_hash, SCRAMBLE41_LENGTH);
unknown's avatar
unknown committed
2553 2554
        mysql->scramble_buff[SCRAMBLE41_LENGTH]=0;
        /* Finally scramble decoded scramble with password */
unknown's avatar
unknown committed
2555
        scramble(buff, mysql->scramble_buff, passwd,
unknown's avatar
unknown committed
2556 2557
                  (my_bool) (mysql->protocol_version == 9));
      }
unknown's avatar
unknown committed
2558
      /* Write second package of authentication */
unknown's avatar
unknown committed
2559
      if (my_net_write(net,buff,SCRAMBLE41_LENGTH) || net_flush(net))
unknown's avatar
unknown committed
2560
      {
unknown's avatar
unknown committed
2561 2562
        net->last_errno= CR_SERVER_LOST;
        strmov(net->last_error,ER(net->last_errno));
unknown's avatar
unknown committed
2563 2564
        goto error;
      }
unknown's avatar
unknown committed
2565
      /* Read What server thinks about out new auth message report */
unknown's avatar
unknown committed
2566 2567 2568 2569
      if (net_safe_read(mysql) == packet_error)
          goto error;
    }
  }
unknown's avatar
unknown committed
2570

unknown's avatar
unknown committed
2571 2572 2573 2574 2575 2576 2577 2578
  my_free(mysql->user,MYF(MY_ALLOW_ZERO_PTR));
  my_free(mysql->passwd,MYF(MY_ALLOW_ZERO_PTR));
  my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));

  mysql->user=  my_strdup(user,MYF(MY_WME));
  mysql->passwd=my_strdup(passwd,MYF(MY_WME));
  mysql->db=    db ? my_strdup(db,MYF(MY_WME)) : 0;
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2579

unknown's avatar
unknown committed
2580 2581
  error:
  DBUG_RETURN(1);
unknown's avatar
unknown committed
2582

unknown's avatar
unknown committed
2583 2584 2585 2586
}


/**************************************************************************
2587
  Set current database
unknown's avatar
unknown committed
2588 2589 2590 2591 2592 2593 2594 2595 2596
**************************************************************************/

int STDCALL
mysql_select_db(MYSQL *mysql, const char *db)
{
  int error;
  DBUG_ENTER("mysql_select_db");
  DBUG_PRINT("enter",("db: '%s'",db));

unknown's avatar
unknown committed
2597
  if ((error=simple_command(mysql,COM_INIT_DB,db,(ulong) strlen(db),0)))
unknown's avatar
unknown committed
2598 2599 2600 2601 2602 2603 2604 2605
    DBUG_RETURN(error);
  my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
  mysql->db=my_strdup(db,MYF(MY_WME));
  DBUG_RETURN(0);
}


/*************************************************************************
2606 2607
  Send a QUIT to the server and close the connection
  If handle is alloced by mysql connect free it.
unknown's avatar
unknown committed
2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619
*************************************************************************/

void STDCALL
mysql_close(MYSQL *mysql)
{
  DBUG_ENTER("mysql_close");
  if (mysql)					/* Some simple safety */
  {
    if (mysql->net.vio != 0)
    {
      free_old_query(mysql);
      mysql->status=MYSQL_STATUS_READY; /* Force command */
2620
      mysql->reconnect=0;
unknown's avatar
unknown committed
2621
      simple_command(mysql,COM_QUIT,NullS,0,1);
unknown's avatar
unknown committed
2622
      end_server(mysql);			/* Sets mysql->net.vio= 0 */
unknown's avatar
unknown committed
2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636
    }
    my_free((gptr) mysql->host_info,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->user,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->passwd,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->options.user,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->options.host,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->options.password,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->options.unix_socket,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->options.db,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->options.charset_dir,MYF(MY_ALLOW_ZERO_PTR));
    my_free(mysql->options.charset_name,MYF(MY_ALLOW_ZERO_PTR));
unknown's avatar
unknown committed
2637 2638
    if (mysql->options.init_commands)
    {
unknown's avatar
unknown committed
2639 2640 2641 2642 2643 2644 2645
      DYNAMIC_ARRAY *init_commands= mysql->options.init_commands;
      char **ptr= (char**)init_commands->buffer;
      char **end= ptr + init_commands->elements;
      for (; ptr<end; ptr++)
	my_free(*ptr,MYF(MY_WME));
      delete_dynamic(init_commands);
      my_free((char*)init_commands,MYF(MY_WME));
unknown's avatar
unknown committed
2646
    }
2647
#ifdef HAVE_OPENSSL
unknown's avatar
unknown committed
2648
    mysql_ssl_free(mysql);
2649
#endif /* HAVE_OPENSSL */
2650 2651 2652 2653
#ifdef HAVE_SMEM
    if (mysql->options.shared_memory_base_name != def_shared_memory_base_name)
      my_free(mysql->options.shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
#endif /* HAVE_SMEM */
unknown's avatar
unknown committed
2654 2655 2656
    /* Clear pointers for better safety */
    mysql->host_info=mysql->user=mysql->passwd=mysql->db=0;
    bzero((char*) &mysql->options,sizeof(mysql->options));
unknown's avatar
unknown committed
2657

2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668
    /* free/close slave list */
    if (mysql->rpl_pivot)
    {
      MYSQL* tmp;
      for (tmp = mysql->next_slave; tmp != mysql; )
      {
	/* trick to avoid following freed pointer */
	MYSQL* tmp1 = tmp->next_slave;
	mysql_close(tmp);
	tmp = tmp1;
      }
2669
      mysql->rpl_pivot=0;
2670
    }
unknown's avatar
unknown committed
2671 2672 2673 2674 2675 2676 2677 2678
    if (mysql->stmts)
    {
      /* Free any open prepared statements */
      LIST *element, *next_element;
      for (element= mysql->stmts; element; element= next_element)
      {
        next_element= element->next;
        stmt_close((MYSQL_STMT *)element->data, 0);
unknown's avatar
unknown committed
2679
      }
unknown's avatar
unknown committed
2680
    }
unknown's avatar
unknown committed
2681
    if (mysql != mysql->master)
2682
      mysql_close(mysql->master);
unknown's avatar
unknown committed
2683 2684 2685 2686 2687 2688 2689 2690
    if (mysql->free_me)
      my_free((gptr) mysql,MYF(0));
  }
  DBUG_VOID_RETURN;
}


/**************************************************************************
2691 2692
  Do a query. If query returned rows, free old rows.
  Read data by mysql_store_result or by repeat call of mysql_fetch_row
unknown's avatar
unknown committed
2693 2694 2695 2696 2697 2698 2699 2700
**************************************************************************/

int STDCALL
mysql_query(MYSQL *mysql, const char *query)
{
  return mysql_real_query(mysql,query, (uint) strlen(query));
}

unknown's avatar
unknown committed
2701

2702
static MYSQL* spawn_init(MYSQL* parent, const char* host,
unknown's avatar
unknown committed
2703 2704
			 unsigned int port, const char* user,
			 const char* passwd)
2705 2706 2707 2708
{
  MYSQL* child;
  if (!(child = mysql_init(0)))
    return 0;
unknown's avatar
unknown committed
2709

2710 2711
  child->options.user = my_strdup((user) ? user :
				  (parent->user ? parent->user :
unknown's avatar
unknown committed
2712 2713 2714 2715
				   parent->options.user), MYF(0));
  child->options.password = my_strdup((passwd) ? passwd :
				      (parent->passwd ?
				       parent->passwd :
2716 2717
				       parent->options.password), MYF(0));
  child->options.port = port;
unknown's avatar
unknown committed
2718 2719 2720 2721 2722
  child->options.host = my_strdup((host) ? host :
				  (parent->host ?
				   parent->host :
				   parent->options.host), MYF(0));
  if (parent->db)
2723
    child->options.db = my_strdup(parent->db, MYF(0));
unknown's avatar
unknown committed
2724
  else if (parent->options.db)
2725 2726 2727
    child->options.db = my_strdup(parent->options.db, MYF(0));

  child->options.rpl_parse = child->options.rpl_probe = child->rpl_pivot = 0;
unknown's avatar
unknown committed
2728

2729 2730 2731 2732 2733 2734
  return child;
}


int
STDCALL mysql_set_master(MYSQL* mysql, const char* host,
unknown's avatar
unknown committed
2735 2736
			 unsigned int port, const char* user,
			 const char* passwd)
2737 2738 2739
{
  if (mysql->master != mysql && !mysql->master->rpl_pivot)
    mysql_close(mysql->master);
unknown's avatar
unknown committed
2740
  if (!(mysql->master = spawn_init(mysql, host, port, user, passwd)))
2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754
    return 1;
  mysql->master->rpl_pivot = 0;
  mysql->master->options.rpl_parse = 0;
  mysql->master->options.rpl_probe = 0;
  return 0;
}

int
STDCALL mysql_add_slave(MYSQL* mysql, const char* host,
					   unsigned int port,
					   const char* user,
					   const char* passwd)
{
  MYSQL* slave;
unknown's avatar
unknown committed
2755
  if (!(slave = spawn_init(mysql, host, port, user, passwd)))
2756 2757 2758 2759 2760 2761 2762
    return 1;
  slave->next_slave = mysql->next_slave;
  mysql->next_slave = slave;
  return 0;
}


2763 2764 2765 2766
/*
  Send the query and return so we can do something else.
  Needs to be followed by mysql_read_query_result() when we want to
  finish processing it.
unknown's avatar
unknown committed
2767
*/
unknown's avatar
unknown committed
2768 2769

int STDCALL
unknown's avatar
unknown committed
2770
mysql_send_query(MYSQL* mysql, const char* query, ulong length)
unknown's avatar
unknown committed
2771
{
unknown's avatar
unknown committed
2772 2773 2774 2775
  DBUG_ENTER("mysql_send_query");
  DBUG_PRINT("enter",("rpl_parse: %d  rpl_pivot: %d",
		      mysql->options.rpl_parse, mysql->rpl_pivot));

2776 2777
  if (mysql->options.rpl_parse && mysql->rpl_pivot)
  {
unknown's avatar
unknown committed
2778
    switch (mysql_rpl_query_type(query, length)) {
2779
    case MYSQL_RPL_MASTER:
unknown's avatar
unknown committed
2780
      DBUG_RETURN(mysql_master_send_query(mysql, query, length));
2781
    case MYSQL_RPL_SLAVE:
unknown's avatar
unknown committed
2782
      DBUG_RETURN(mysql_slave_send_query(mysql, query, length));
unknown's avatar
unknown committed
2783 2784
    case MYSQL_RPL_ADMIN:
      break;					/* fall through */
2785 2786 2787 2788
    }
  }

  mysql->last_used_con = mysql;
unknown's avatar
unknown committed
2789
  DBUG_RETURN(simple_command(mysql, COM_QUERY, query, length, 1));
unknown's avatar
unknown committed
2790
}
unknown's avatar
unknown committed
2791

unknown's avatar
unknown committed
2792

2793
my_bool STDCALL mysql_read_query_result(MYSQL *mysql)
unknown's avatar
unknown committed
2794 2795 2796 2797
{
  uchar *pos;
  ulong field_count;
  MYSQL_DATA *fields;
2798
  ulong length;
2799
  DBUG_ENTER("mysql_read_query_result");
unknown's avatar
unknown committed
2800

2801 2802 2803 2804
  /*
    Read from the connection which we actually used, which
    could differ from the original connection if we have slaves
  */
2805
  mysql = mysql->last_used_con;
unknown's avatar
unknown committed
2806

2807
  if ((length = net_safe_read(mysql)) == packet_error)
2808
    DBUG_RETURN(1);
unknown's avatar
unknown committed
2809
  free_old_query(mysql);			/* Free old result */
2810
get_info:
unknown's avatar
unknown committed
2811 2812 2813 2814 2815
  pos=(uchar*) mysql->net.read_pos;
  if ((field_count= net_field_length(&pos)) == 0)
  {
    mysql->affected_rows= net_field_length_ll(&pos);
    mysql->insert_id=	  net_field_length_ll(&pos);
unknown's avatar
unknown committed
2816
    if (protocol_41(mysql))
unknown's avatar
unknown committed
2817 2818
    {
      mysql->server_status=uint2korr(pos); pos+=2;
2819
      mysql->warning_count=uint2korr(pos); pos+=2;
unknown's avatar
unknown committed
2820
    }
2821
    else if (mysql->server_capabilities & CLIENT_TRANSACTIONS)
unknown's avatar
unknown committed
2822 2823
    {
      mysql->server_status=uint2korr(pos); pos+=2;
2824
      mysql->warning_count= 0;
unknown's avatar
unknown committed
2825
    }
2826 2827
    DBUG_PRINT("info",("status: %ld  warning_count:  %ld",
		       mysql->server_status, mysql->warning_count));
unknown's avatar
unknown committed
2828 2829 2830 2831 2832 2833 2834 2835
    if (pos < mysql->net.read_pos+length && net_field_length(&pos))
      mysql->info=(char*) pos;
    DBUG_RETURN(0);
  }
  if (field_count == NULL_LENGTH)		/* LOAD DATA LOCAL INFILE */
  {
    int error=send_file_to_server(mysql,(char*) pos);
    if ((length=net_safe_read(mysql)) == packet_error || error)
2836
      DBUG_RETURN(1);
unknown's avatar
unknown committed
2837 2838 2839 2840 2841 2842
    goto get_info;				/* Get info packet */
  }
  if (!(mysql->server_status & SERVER_STATUS_AUTOCOMMIT))
    mysql->server_status|= SERVER_STATUS_IN_TRANS;

  mysql->extra_info= net_field_length_ll(&pos); /* Maybe number of rec */
2843

2844 2845
  if (!(fields=read_rows(mysql,(MYSQL_FIELD*)0, (protocol_41(mysql) ? 8 : 5))))
    DBUG_RETURN(1);
unknown's avatar
unknown committed
2846 2847
  if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,
				    (uint) field_count,0,
2848
				    mysql->server_capabilities)))
2849 2850
    DBUG_RETURN(1);
  mysql->status= MYSQL_STATUS_GET_RESULT;
unknown's avatar
unknown committed
2851
  mysql->field_count= (uint) field_count;
2852
  mysql->warning_count= 0;
unknown's avatar
unknown committed
2853 2854 2855
  DBUG_RETURN(0);
}

unknown's avatar
unknown committed
2856

2857
int STDCALL
unknown's avatar
unknown committed
2858
mysql_real_query(MYSQL *mysql, const char *query, ulong length)
2859 2860 2861
{
  DBUG_ENTER("mysql_real_query");
  DBUG_PRINT("enter",("handle: %lx",mysql));
2862
  DBUG_PRINT("query",("Query = '%-.4096s'",query));
unknown's avatar
unknown committed
2863

2864
  if (mysql_send_query(mysql,query,length))
2865 2866
    DBUG_RETURN(1);
  DBUG_RETURN((int) mysql_read_query_result(mysql));
2867
}
unknown's avatar
unknown committed
2868

unknown's avatar
unknown committed
2869

2870
static my_bool
unknown's avatar
unknown committed
2871 2872
send_file_to_server(MYSQL *mysql, const char *filename)
{
2873 2874
  int fd, readcount;
  my_bool result= 1;
unknown's avatar
unknown committed
2875 2876
  uint packet_length=MY_ALIGN(mysql->net.max_packet-16,IO_SIZE);
  char *buf, tmp_name[FN_REFLEN];
unknown's avatar
unknown committed
2877 2878
  DBUG_ENTER("send_file_to_server");

unknown's avatar
unknown committed
2879
  if (!(buf=my_malloc(packet_length,MYF(0))))
unknown's avatar
unknown committed
2880 2881
  {
    strmov(mysql->net.last_error, ER(mysql->net.last_errno=CR_OUT_OF_MEMORY));
2882
    DBUG_RETURN(1);
unknown's avatar
unknown committed
2883
  }
unknown's avatar
unknown committed
2884 2885

  fn_format(tmp_name,filename,"","",4);		/* Convert to client format */
unknown's avatar
unknown committed
2886 2887
  if ((fd = my_open(tmp_name,O_RDONLY, MYF(0))) < 0)
  {
unknown's avatar
unknown committed
2888 2889
    my_net_write(&mysql->net,"",0);		/* Server needs one packet */
    net_flush(&mysql->net);
unknown's avatar
unknown committed
2890
    mysql->net.last_errno=EE_FILENOTFOUND;
unknown's avatar
unknown committed
2891 2892
    my_snprintf(mysql->net.last_error,sizeof(mysql->net.last_error)-1,
		EE(mysql->net.last_errno),tmp_name, errno);
unknown's avatar
unknown committed
2893
    goto err;
unknown's avatar
unknown committed
2894 2895
  }

unknown's avatar
unknown committed
2896
  while ((readcount = (int) my_read(fd,(byte*) buf,packet_length,MYF(0))) > 0)
unknown's avatar
unknown committed
2897 2898 2899
  {
    if (my_net_write(&mysql->net,buf,readcount))
    {
unknown's avatar
unknown committed
2900
      DBUG_PRINT("error",("Lost connection to MySQL server during LOAD DATA of local file"));
unknown's avatar
unknown committed
2901 2902
      mysql->net.last_errno=CR_SERVER_LOST;
      strmov(mysql->net.last_error,ER(mysql->net.last_errno));
unknown's avatar
unknown committed
2903
      goto err;
unknown's avatar
unknown committed
2904 2905 2906 2907 2908 2909
    }
  }
  /* Send empty packet to mark end of file */
  if (my_net_write(&mysql->net,"",0) || net_flush(&mysql->net))
  {
    mysql->net.last_errno=CR_SERVER_LOST;
unknown's avatar
unknown committed
2910 2911
    sprintf(mysql->net.last_error,ER(mysql->net.last_errno),errno);
    goto err;
unknown's avatar
unknown committed
2912 2913 2914 2915
  }
  if (readcount < 0)
  {
    mysql->net.last_errno=EE_READ; /* the errmsg for not entire file read */
unknown's avatar
unknown committed
2916 2917
    my_snprintf(mysql->net.last_error,sizeof(mysql->net.last_error)-1,
		tmp_name,errno);
unknown's avatar
unknown committed
2918
    goto err;
unknown's avatar
unknown committed
2919
  }
unknown's avatar
unknown committed
2920 2921 2922 2923 2924 2925 2926
  result=0;					/* Ok */

err:
  if (fd >= 0)
    (void) my_close(fd,MYF(0));
  my_free(buf,MYF(0));
  DBUG_RETURN(result);
unknown's avatar
unknown committed
2927 2928 2929 2930
}


/**************************************************************************
2931 2932
  Alloc result struct for buffered results. All rows are read to buffer.
  mysql_data_seek may be used.
unknown's avatar
unknown committed
2933 2934 2935 2936 2937 2938 2939 2940
**************************************************************************/

MYSQL_RES * STDCALL
mysql_store_result(MYSQL *mysql)
{
  MYSQL_RES *result;
  DBUG_ENTER("mysql_store_result");

2941 2942
  /* read from the actually used connection */
  mysql = mysql->last_used_con;
unknown's avatar
unknown committed
2943

unknown's avatar
unknown committed
2944 2945 2946 2947 2948 2949 2950 2951 2952
  if (!mysql->fields)
    DBUG_RETURN(0);
  if (mysql->status != MYSQL_STATUS_GET_RESULT)
  {
    strmov(mysql->net.last_error,
	   ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
    DBUG_RETURN(0);
  }
  mysql->status=MYSQL_STATUS_READY;		/* server is ready */
unknown's avatar
unknown committed
2953 2954 2955
  if (!(result=(MYSQL_RES*) my_malloc((uint) (sizeof(MYSQL_RES)+
					      sizeof(ulong) *
					      mysql->field_count),
unknown's avatar
unknown committed
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
				      MYF(MY_WME | MY_ZEROFILL))))
  {
    mysql->net.last_errno=CR_OUT_OF_MEMORY;
    strmov(mysql->net.last_error, ER(mysql->net.last_errno));
    DBUG_RETURN(0);
  }
  result->eof=1;				/* Marker for buffered */
  result->lengths=(ulong*) (result+1);
  if (!(result->data=read_rows(mysql,mysql->fields,mysql->field_count)))
  {
    my_free((gptr) result,MYF(0));
    DBUG_RETURN(0);
  }
  mysql->affected_rows= result->row_count= result->data->rows;
  result->data_cursor=	result->data->data;
  result->fields=	mysql->fields;
  result->field_alloc=	mysql->field_alloc;
  result->field_count=	mysql->field_count;
  result->current_field=0;
  result->current_row=0;			/* Must do a fetch first */
  mysql->fields=0;				/* fields is now in result */
  DBUG_RETURN(result);				/* Data fetched */
}


/**************************************************************************
2982 2983 2984 2985 2986 2987 2988
  Alloc struct for use with unbuffered reads. Data is fetched by domand
  when calling to mysql_fetch_row.
  mysql_data_seek is a noop.

  No other queries may be specified with the same MYSQL handle.
  There shouldn't be much processing per row because mysql server shouldn't
  have to wait for the client (and will not wait more than 30 sec/packet).
unknown's avatar
unknown committed
2989 2990 2991 2992 2993 2994 2995 2996
**************************************************************************/

MYSQL_RES * STDCALL
mysql_use_result(MYSQL *mysql)
{
  MYSQL_RES *result;
  DBUG_ENTER("mysql_use_result");

2997
  mysql = mysql->last_used_con;
unknown's avatar
unknown committed
2998

unknown's avatar
unknown committed
2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031
  if (!mysql->fields)
    DBUG_RETURN(0);
  if (mysql->status != MYSQL_STATUS_GET_RESULT)
  {
    strmov(mysql->net.last_error,
	   ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
    DBUG_RETURN(0);
  }
  if (!(result=(MYSQL_RES*) my_malloc(sizeof(*result)+
				      sizeof(ulong)*mysql->field_count,
				      MYF(MY_WME | MY_ZEROFILL))))
    DBUG_RETURN(0);
  result->lengths=(ulong*) (result+1);
  if (!(result->row=(MYSQL_ROW)
	my_malloc(sizeof(result->row[0])*(mysql->field_count+1), MYF(MY_WME))))
  {					/* Ptrs: to one row */
    my_free((gptr) result,MYF(0));
    DBUG_RETURN(0);
  }
  result->fields=	mysql->fields;
  result->field_alloc=	mysql->field_alloc;
  result->field_count=	mysql->field_count;
  result->current_field=0;
  result->handle=	mysql;
  result->current_row=	0;
  mysql->fields=0;			/* fields is now in result */
  mysql->status=MYSQL_STATUS_USE_RESULT;
  DBUG_RETURN(result);			/* Data is read to be fetched */
}



/**************************************************************************
3032
  Return next field of the query results
unknown's avatar
unknown committed
3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044
**************************************************************************/

MYSQL_FIELD * STDCALL
mysql_fetch_field(MYSQL_RES *result)
{
  if (result->current_field >= result->field_count)
    return(NULL);
  return &result->fields[result->current_field++];
}


/**************************************************************************
3045
   Return next row of the query results
unknown's avatar
unknown committed
3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065
**************************************************************************/

MYSQL_ROW STDCALL
mysql_fetch_row(MYSQL_RES *res)
{
  DBUG_ENTER("mysql_fetch_row");
  if (!res->data)
  {						/* Unbufferred fetch */
    if (!res->eof)
    {
      if (!(read_one_row(res->handle,res->field_count,res->row, res->lengths)))
      {
	res->row_count++;
	DBUG_RETURN(res->current_row=res->row);
      }
      else
      {
	DBUG_PRINT("info",("end of data"));
	res->eof=1;
	res->handle->status=MYSQL_STATUS_READY;
unknown's avatar
unknown committed
3066 3067
	/* Don't clear handle in mysql_free_results */
	res->handle=0;
unknown's avatar
unknown committed
3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085
      }
    }
    DBUG_RETURN((MYSQL_ROW) NULL);
  }
  {
    MYSQL_ROW tmp;
    if (!res->data_cursor)
    {
      DBUG_PRINT("info",("end of data"));
      DBUG_RETURN(res->current_row=(MYSQL_ROW) NULL);
    }
    tmp = res->data_cursor->data;
    res->data_cursor = res->data_cursor->next;
    DBUG_RETURN(res->current_row=tmp);
  }
}

/**************************************************************************
3086 3087 3088
  Get column lengths of the current row
  If one uses mysql_use_result, res->lengths contains the length information,
  else the lengths are calculated from the offset between pointers.
unknown's avatar
unknown committed
3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112
**************************************************************************/

ulong * STDCALL
mysql_fetch_lengths(MYSQL_RES *res)
{
  ulong *lengths,*prev_length;
  byte *start;
  MYSQL_ROW column,end;

  if (!(column=res->current_row))
    return 0;					/* Something is wrong */
  if (res->data)
  {
    start=0;
    prev_length=0;				/* Keep gcc happy */
    lengths=res->lengths;
    for (end=column+res->field_count+1 ; column != end ; column++,lengths++)
    {
      if (!*column)
      {
	*lengths=0;				/* Null */
	continue;
      }
      if (start)				/* Found end of prev string */
unknown's avatar
unknown committed
3113
	*prev_length= (ulong) (*column-start-1);
unknown's avatar
unknown committed
3114 3115 3116 3117 3118 3119 3120 3121
      start= *column;
      prev_length=lengths;
    }
  }
  return res->lengths;
}

/**************************************************************************
3122
  Move to a specific row and column
unknown's avatar
unknown committed
3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136
**************************************************************************/

void STDCALL
mysql_data_seek(MYSQL_RES *result, my_ulonglong row)
{
  MYSQL_ROWS	*tmp=0;
  DBUG_PRINT("info",("mysql_data_seek(%ld)",(long) row));
  if (result->data)
    for (tmp=result->data->data; row-- && tmp ; tmp = tmp->next) ;
  result->current_row=0;
  result->data_cursor = tmp;
}

/*************************************************************************
3137 3138 3139
  put the row or field cursor one a position one got from mysql_row_tell()
  This doesn't restore any data. The next mysql_fetch_row or
  mysql_fetch_field will return the next row or field after the last used
unknown's avatar
unknown committed
3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160
*************************************************************************/

MYSQL_ROW_OFFSET STDCALL
mysql_row_seek(MYSQL_RES *result, MYSQL_ROW_OFFSET row)
{
  MYSQL_ROW_OFFSET return_value=result->data_cursor;
  result->current_row= 0;
  result->data_cursor= row;
  return return_value;
}


MYSQL_FIELD_OFFSET STDCALL
mysql_field_seek(MYSQL_RES *result, MYSQL_FIELD_OFFSET field_offset)
{
  MYSQL_FIELD_OFFSET return_value=result->current_field;
  result->current_field=field_offset;
  return return_value;
}

/*****************************************************************************
3161
  List all databases
unknown's avatar
unknown committed
3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177
*****************************************************************************/

MYSQL_RES * STDCALL
mysql_list_dbs(MYSQL *mysql, const char *wild)
{
  char buff[255];
  DBUG_ENTER("mysql_list_dbs");

  append_wild(strmov(buff,"show databases"),buff+sizeof(buff),wild);
  if (mysql_query(mysql,buff))
    DBUG_RETURN(0);
  DBUG_RETURN (mysql_store_result(mysql));
}


/*****************************************************************************
3178 3179
  List all tables in a database
  If wild is given then only the tables matching wild is returned
unknown's avatar
unknown committed
3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195
*****************************************************************************/

MYSQL_RES * STDCALL
mysql_list_tables(MYSQL *mysql, const char *wild)
{
  char buff[255];
  DBUG_ENTER("mysql_list_tables");

  append_wild(strmov(buff,"show tables"),buff+sizeof(buff),wild);
  if (mysql_query(mysql,buff))
    DBUG_RETURN(0);
  DBUG_RETURN (mysql_store_result(mysql));
}


/**************************************************************************
3196 3197 3198 3199
  List all fields in a table
  If wild is given then only the fields matching wild is returned
  Instead of this use query:
  show fields in 'table' like "wild"
unknown's avatar
unknown committed
3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213
**************************************************************************/

MYSQL_RES * STDCALL
mysql_list_fields(MYSQL *mysql, const char *table, const char *wild)
{
  MYSQL_RES *result;
  MYSQL_DATA *query;
  char	     buff[257],*end;
  DBUG_ENTER("mysql_list_fields");
  DBUG_PRINT("enter",("table: '%s'  wild: '%s'",table,wild ? wild : ""));

  LINT_INIT(query);

  end=strmake(strmake(buff, table,128)+1,wild ? wild : "",128);
unknown's avatar
unknown committed
3214
  if (simple_command(mysql,COM_FIELD_LIST,buff,(ulong) (end-buff),1) ||
3215 3216
      !(query = read_rows(mysql,(MYSQL_FIELD*) 0,
			  (protocol_41(mysql) ? 9 : 6))))
unknown's avatar
unknown committed
3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229
    DBUG_RETURN(NULL);

  free_old_query(mysql);
  if (!(result = (MYSQL_RES *) my_malloc(sizeof(MYSQL_RES),
					 MYF(MY_WME | MY_ZEROFILL))))
  {
    free_rows(query);
    DBUG_RETURN(NULL);
  }
  result->field_alloc=mysql->field_alloc;
  mysql->fields=0;
  result->field_count = (uint) query->rows;
  result->fields= unpack_fields(query,&result->field_alloc,
3230 3231
				result->field_count, 1,
				mysql->server_capabilities);
unknown's avatar
unknown committed
3232 3233 3234 3235
  result->eof=1;
  DBUG_RETURN(result);
}

3236

unknown's avatar
unknown committed
3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252
/* List all running processes (threads) in server */

MYSQL_RES * STDCALL
mysql_list_processes(MYSQL *mysql)
{
  MYSQL_DATA *fields;
  uint field_count;
  uchar *pos;
  DBUG_ENTER("mysql_list_processes");

  LINT_INIT(fields);
  if (simple_command(mysql,COM_PROCESS_INFO,0,0,0))
    DBUG_RETURN(0);
  free_old_query(mysql);
  pos=(uchar*) mysql->net.read_pos;
  field_count=(uint) net_field_length(&pos);
3253
  if (!(fields = read_rows(mysql,(MYSQL_FIELD*)0,protocol_41(mysql) ? 8: 5)))
unknown's avatar
unknown committed
3254 3255
    DBUG_RETURN(NULL);
  if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,field_count,0,
3256
				    mysql->server_capabilities)))
unknown's avatar
unknown committed
3257 3258 3259 3260 3261 3262 3263
    DBUG_RETURN(0);
  mysql->status=MYSQL_STATUS_GET_RESULT;
  mysql->field_count=field_count;
  DBUG_RETURN(mysql_store_result(mysql));
}


3264
#ifdef USE_OLD_FUNCTIONS
unknown's avatar
unknown committed
3265 3266 3267 3268 3269
int  STDCALL
mysql_create_db(MYSQL *mysql, const char *db)
{
  DBUG_ENTER("mysql_createdb");
  DBUG_PRINT("enter",("db: %s",db));
unknown's avatar
unknown committed
3270
  DBUG_RETURN(simple_command(mysql,COM_CREATE_DB,db, (ulong) strlen(db),0));
unknown's avatar
unknown committed
3271 3272 3273 3274 3275 3276 3277 3278
}


int  STDCALL
mysql_drop_db(MYSQL *mysql, const char *db)
{
  DBUG_ENTER("mysql_drop_db");
  DBUG_PRINT("enter",("db: %s",db));
unknown's avatar
unknown committed
3279
  DBUG_RETURN(simple_command(mysql,COM_DROP_DB,db,(ulong) strlen(db),0));
unknown's avatar
unknown committed
3280
}
3281
#endif
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 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317


int STDCALL
mysql_shutdown(MYSQL *mysql)
{
  DBUG_ENTER("mysql_shutdown");
  DBUG_RETURN(simple_command(mysql,COM_SHUTDOWN,0,0,0));
}


int STDCALL
mysql_refresh(MYSQL *mysql,uint options)
{
  uchar bits[1];
  DBUG_ENTER("mysql_refresh");
  bits[0]= (uchar) options;
  DBUG_RETURN(simple_command(mysql,COM_REFRESH,(char*) bits,1,0));
}

int STDCALL
mysql_kill(MYSQL *mysql,ulong pid)
{
  char buff[12];
  DBUG_ENTER("mysql_kill");
  int4store(buff,pid);
  DBUG_RETURN(simple_command(mysql,COM_PROCESS_KILL,buff,4,0));
}


int STDCALL
mysql_dump_debug_info(MYSQL *mysql)
{
  DBUG_ENTER("mysql_dump_debug_info");
  DBUG_RETURN(simple_command(mysql,COM_DEBUG,0,0,0));
}

unknown's avatar
unknown committed
3318
const char * STDCALL
unknown's avatar
unknown committed
3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342
mysql_stat(MYSQL *mysql)
{
  DBUG_ENTER("mysql_stat");
  if (simple_command(mysql,COM_STATISTICS,0,0,0))
    return mysql->net.last_error;
  mysql->net.read_pos[mysql->packet_length]=0;	/* End of stat string */
  if (!mysql->net.read_pos[0])
  {
    mysql->net.last_errno=CR_WRONG_HOST_INFO;
    strmov(mysql->net.last_error, ER(mysql->net.last_errno));
    return mysql->net.last_error;
  }
  DBUG_RETURN((char*) mysql->net.read_pos);
}


int STDCALL
mysql_ping(MYSQL *mysql)
{
  DBUG_ENTER("mysql_ping");
  DBUG_RETURN(simple_command(mysql,COM_PING,0,0,0));
}


unknown's avatar
unknown committed
3343
const char * STDCALL
unknown's avatar
unknown committed
3344 3345 3346 3347 3348 3349
mysql_get_server_info(MYSQL *mysql)
{
  return((char*) mysql->server_version);
}


unknown's avatar
unknown committed
3350
const char * STDCALL
unknown's avatar
unknown committed
3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362
mysql_get_host_info(MYSQL *mysql)
{
  return(mysql->host_info);
}


uint STDCALL
mysql_get_proto_info(MYSQL *mysql)
{
  return (mysql->protocol_version);
}

unknown's avatar
unknown committed
3363
const char * STDCALL
unknown's avatar
unknown committed
3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379
mysql_get_client_info(void)
{
  return (char*) MYSQL_SERVER_VERSION;
}


int STDCALL
mysql_options(MYSQL *mysql,enum mysql_option option, const char *arg)
{
  DBUG_ENTER("mysql_option");
  DBUG_PRINT("enter",("option: %d",(int) option));
  switch (option) {
  case MYSQL_OPT_CONNECT_TIMEOUT:
    mysql->options.connect_timeout= *(uint*) arg;
    break;
  case MYSQL_OPT_COMPRESS:
3380
    mysql->options.compress= 1;			/* Remember for connect */
3381
    mysql->options.client_flag|= CLIENT_COMPRESS;
unknown's avatar
unknown committed
3382 3383
    break;
  case MYSQL_OPT_NAMED_PIPE:
3384
    mysql->options.protocol=MYSQL_PROTOCOL_PIPE; /* Force named pipe */
unknown's avatar
unknown committed
3385
    break;
3386 3387
  case MYSQL_OPT_LOCAL_INFILE:			/* Allow LOAD DATA LOCAL ?*/
    if (!arg || test(*(uint*) arg))
3388
      mysql->options.client_flag|= CLIENT_LOCAL_FILES;
3389
    else
3390
      mysql->options.client_flag&= ~CLIENT_LOCAL_FILES;
3391
    break;
unknown's avatar
unknown committed
3392
  case MYSQL_INIT_COMMAND:
unknown's avatar
unknown committed
3393
    add_init_command(&mysql->options,arg);
unknown's avatar
unknown committed
3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410
    break;
  case MYSQL_READ_DEFAULT_FILE:
    my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
    mysql->options.my_cnf_file=my_strdup(arg,MYF(MY_WME));
    break;
  case MYSQL_READ_DEFAULT_GROUP:
    my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
    mysql->options.my_cnf_group=my_strdup(arg,MYF(MY_WME));
    break;
  case MYSQL_SET_CHARSET_DIR:
    my_free(mysql->options.charset_dir,MYF(MY_ALLOW_ZERO_PTR));
    mysql->options.charset_dir=my_strdup(arg,MYF(MY_WME));
    break;
  case MYSQL_SET_CHARSET_NAME:
    my_free(mysql->options.charset_name,MYF(MY_ALLOW_ZERO_PTR));
    mysql->options.charset_name=my_strdup(arg,MYF(MY_WME));
    break;
3411 3412 3413 3414 3415 3416 3417 3418 3419 3420
  case MYSQL_OPT_PROTOCOL:
    mysql->options.protocol= *(uint*) arg;
    break;
  case MYSQL_SHARED_MEMORY_BASE_NAME:
#ifdef HAVE_SMEM
    if (mysql->options.shared_memory_base_name != def_shared_memory_base_name)
      my_free(mysql->options.shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
    mysql->options.shared_memory_base_name=my_strdup(arg,MYF(MY_WME));
#endif
    break;
unknown's avatar
unknown committed
3421
  default:
3422
    DBUG_RETURN(1);
unknown's avatar
unknown committed
3423 3424 3425 3426 3427
  }
  DBUG_RETURN(0);
}

/****************************************************************************
3428 3429
  Functions to get information from the MySQL structure
  These are functions to make shared libraries more usable.
unknown's avatar
unknown committed
3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457
****************************************************************************/

/* MYSQL_RES */
my_ulonglong STDCALL mysql_num_rows(MYSQL_RES *res)
{
  return res->row_count;
}

unsigned int STDCALL mysql_num_fields(MYSQL_RES *res)
{
  return res->field_count;
}

my_bool STDCALL mysql_eof(MYSQL_RES *res)
{
  return res->eof;
}

MYSQL_FIELD * STDCALL mysql_fetch_field_direct(MYSQL_RES *res,uint fieldnr)
{
  return &(res)->fields[fieldnr];
}

MYSQL_FIELD * STDCALL mysql_fetch_fields(MYSQL_RES *res)
{
  return (res)->fields;
}

unknown's avatar
unknown committed
3458
MYSQL_ROW_OFFSET STDCALL mysql_row_tell(MYSQL_RES *res)
unknown's avatar
unknown committed
3459 3460 3461 3462
{
  return res->data_cursor;
}

unknown's avatar
unknown committed
3463
MYSQL_FIELD_OFFSET STDCALL mysql_field_tell(MYSQL_RES *res)
unknown's avatar
unknown committed
3464 3465 3466 3467 3468 3469 3470 3471
{
  return (res)->current_field;
}

/* MYSQL */

unsigned int STDCALL mysql_field_count(MYSQL *mysql)
{
3472
  return mysql->last_used_con->field_count;
unknown's avatar
unknown committed
3473 3474 3475 3476
}

my_ulonglong STDCALL mysql_affected_rows(MYSQL *mysql)
{
3477
  return mysql->last_used_con->affected_rows;
unknown's avatar
unknown committed
3478 3479 3480 3481
}

my_ulonglong STDCALL mysql_insert_id(MYSQL *mysql)
{
3482
  return mysql->last_used_con->insert_id;
unknown's avatar
unknown committed
3483 3484 3485 3486
}

uint STDCALL mysql_errno(MYSQL *mysql)
{
3487
  return mysql->net.last_errno;
unknown's avatar
unknown committed
3488 3489
}

unknown's avatar
unknown committed
3490
const char * STDCALL mysql_error(MYSQL *mysql)
unknown's avatar
unknown committed
3491
{
3492
  return mysql->net.last_error;
unknown's avatar
unknown committed
3493 3494
}

3495 3496 3497 3498 3499
uint STDCALL mysql_warning_count(MYSQL *mysql)
{
  return mysql->warning_count;
}

unknown's avatar
unknown committed
3500
const char *STDCALL mysql_info(MYSQL *mysql)
unknown's avatar
unknown committed
3501
{
3502
  return mysql->info;
unknown's avatar
unknown committed
3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525
}

ulong STDCALL mysql_thread_id(MYSQL *mysql)
{
  return (mysql)->thread_id;
}

const char * STDCALL mysql_character_set_name(MYSQL *mysql)
{
  return mysql->charset->name;
}


uint STDCALL mysql_thread_safe(void)
{
#ifdef THREAD
  return 1;
#else
  return 0;
#endif
}

/****************************************************************************
3526
  Some support functions
unknown's avatar
unknown committed
3527 3528
****************************************************************************/

unknown's avatar
unknown committed
3529 3530 3531 3532 3533 3534 3535 3536 3537
/*
  Functions called my my_net_init() to set some application specific variables
*/

void my_net_local_init(NET *net)
{
  net->max_packet=   (uint) net_buffer_length;
  net->read_timeout= (uint) net_read_timeout;
  net->write_timeout=(uint) net_write_timeout;
3538
  net->retry_count=  1;
unknown's avatar
unknown committed
3539 3540 3541
  net->max_packet_size= max(net_buffer_length, max_allowed_packet);
}

unknown's avatar
unknown committed
3542
/*
3543 3544 3545
  Add escape characters to a string (blob?) to make it suitable for a insert
  to should at least have place for length*2+1 chars
  Returns the length of the to string
unknown's avatar
unknown committed
3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721
*/

ulong STDCALL
mysql_escape_string(char *to,const char *from,ulong length)
{
  return mysql_sub_escape_string(default_charset_info,to,from,length);
}

ulong STDCALL
mysql_real_escape_string(MYSQL *mysql, char *to,const char *from,
			 ulong length)
{
  return mysql_sub_escape_string(mysql->charset,to,from,length);
}


static ulong
mysql_sub_escape_string(CHARSET_INFO *charset_info, char *to,
			const char *from, ulong length)
{
  const char *to_start=to;
  const char *end;
#ifdef USE_MB
  my_bool use_mb_flag=use_mb(charset_info);
#endif
  for (end=from+length; from != end ; from++)
  {
#ifdef USE_MB
    int l;
    if (use_mb_flag && (l = my_ismbchar(charset_info, from, end)))
    {
      while (l--)
	  *to++ = *from++;
      from--;
      continue;
    }
#endif
    switch (*from) {
    case 0:				/* Must be escaped for 'mysql' */
      *to++= '\\';
      *to++= '0';
      break;
    case '\n':				/* Must be escaped for logs */
      *to++= '\\';
      *to++= 'n';
      break;
    case '\r':
      *to++= '\\';
      *to++= 'r';
      break;
    case '\\':
      *to++= '\\';
      *to++= '\\';
      break;
    case '\'':
      *to++= '\\';
      *to++= '\'';
      break;
    case '"':				/* Better safe than sorry */
      *to++= '\\';
      *to++= '"';
      break;
    case '\032':			/* This gives problems on Win32 */
      *to++= '\\';
      *to++= 'Z';
      break;
    default:
      *to++= *from;
    }
  }
  *to=0;
  return (ulong) (to-to_start);
}


char * STDCALL
mysql_odbc_escape_string(MYSQL *mysql,
			 char *to, ulong to_length,
			 const char *from, ulong from_length,
			 void *param,
			 char * (*extend_buffer)
			 (void *, char *, ulong *))
{
  char *to_end=to+to_length-5;
  const char *end;
#ifdef USE_MB
  my_bool use_mb_flag=use_mb(mysql->charset);
#endif

  for (end=from+from_length; from != end ; from++)
  {
    if (to >= to_end)
    {
      to_length = (ulong) (end-from)+512;	/* We want this much more */
      if (!(to=(*extend_buffer)(param, to, &to_length)))
	return to;
      to_end=to+to_length-5;
    }
#ifdef USE_MB
    {
      int l;
      if (use_mb_flag && (l = my_ismbchar(mysql->charset, from, end)))
      {
	while (l--)
	  *to++ = *from++;
	from--;
	continue;
      }
    }
#endif
    switch (*from) {
    case 0:				/* Must be escaped for 'mysql' */
      *to++= '\\';
      *to++= '0';
      break;
    case '\n':				/* Must be escaped for logs */
      *to++= '\\';
      *to++= 'n';
      break;
    case '\r':
      *to++= '\\';
      *to++= 'r';
      break;
    case '\\':
      *to++= '\\';
      *to++= '\\';
      break;
    case '\'':
      *to++= '\\';
      *to++= '\'';
      break;
    case '"':				/* Better safe than sorry */
      *to++= '\\';
      *to++= '"';
      break;
    case '\032':			/* This gives problems on Win32 */
      *to++= '\\';
      *to++= 'Z';
      break;
    default:
      *to++= *from;
    }
  }
  return to;
}

void STDCALL
myodbc_remove_escape(MYSQL *mysql,char *name)
{
  char *to;
#ifdef USE_MB
  my_bool use_mb_flag=use_mb(mysql->charset);
  char *end;
  LINT_INIT(end);
  if (use_mb_flag)
    for (end=name; *end ; end++) ;
#endif

  for (to=name ; *name ; name++)
  {
#ifdef USE_MB
    int l;
    if (use_mb_flag && (l = my_ismbchar( mysql->charset, name , end ) ) )
    {
      while (l--)
	*to++ = *name++;
      name--;
      continue;
    }
#endif
    if (*name == '\\' && name[1])
      name++;
    *to++= *name;
  }
  *to=0;
}
3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736

/********************************************************************

 Implementation of new client-server prototypes for 4.1 version
 starts from here ..

 mysql_* are real prototypes used by applications

*********************************************************************/

/********************************************************************
 Misc Utility functions
********************************************************************/

/*
3737
  Set the internal stmt error messages
3738 3739 3740 3741 3742
*/

static void set_stmt_error(MYSQL_STMT * stmt, int errcode)
{
  DBUG_ENTER("set_stmt_error");
3743
  DBUG_PRINT("enter", ("error: %d '%s'", errcode, ER(errcode)));
3744 3745
  DBUG_ASSERT(stmt != 0);

3746 3747
  stmt->last_errno= errcode;
  strmov(stmt->last_error, ER(errcode));
3748 3749 3750 3751

  DBUG_VOID_RETURN;
}

3752

3753
/*
3754
  Copy error message to statement handler
3755 3756 3757 3758 3759
*/

static void set_stmt_errmsg(MYSQL_STMT * stmt, char *err, int errcode)
{
  DBUG_ENTER("set_stmt_error_msg");
3760
  DBUG_PRINT("enter", ("error: %d '%s'", errcode, err));
3761 3762
  DBUG_ASSERT(stmt != 0);

3763
  stmt->last_errno= errcode;
3764
  if (err && err[0])
3765
    strmov(stmt->last_error, err);
3766 3767 3768 3769

  DBUG_VOID_RETURN;
}

3770

3771
/*
3772
  Set the internal error message to mysql handler
3773 3774 3775 3776 3777
*/

static void set_mysql_error(MYSQL * mysql, int errcode)
{
  DBUG_ENTER("set_mysql_error");
3778
  DBUG_PRINT("enter", ("error :%d '%s'", errcode, ER(errcode)));
3779 3780
  DBUG_ASSERT(mysql != 0);

3781
  mysql->net.last_errno= errcode;
3782 3783 3784 3785 3786
  strmov(mysql->net.last_error, ER(errcode));
}


/*
3787
  Reallocate the NET package to be at least of 'length' bytes
3788

3789 3790 3791 3792
  SYNPOSIS
   my_realloc_str()
   net			The NET structure to modify
   int length		Ensure that net->buff is at least this big
3793

3794 3795 3796
  RETURN VALUES
  0	ok
  1	Error
3797 3798 3799

*/

3800
static my_bool my_realloc_str(NET *net, ulong length)
3801
{
3802 3803 3804 3805
  ulong buf_length= (ulong) (net->write_pos - net->buff);
  my_bool res=0;
  DBUG_ENTER("my_realloc_str");
  if (buf_length + length > net->max_packet)
3806
  {
3807 3808
    res= net_realloc(net, buf_length + length);
    net->write_pos= net->buff+ buf_length;
3809
  }
3810
  DBUG_RETURN(res);
3811 3812 3813
}

/********************************************************************
3814
  Prepare related implementations
3815 3816 3817 3818
********************************************************************/

/*
  Read the prepare statement results ..
3819 3820 3821 3822 3823 3824 3825 3826

  NOTE
    This is only called for connection to servers that supports
    prepared statements (and thus the 4.1 protocol)

  RETURN VALUES
    0	ok
    1	error
3827 3828
*/

unknown's avatar
unknown committed
3829
static my_bool read_prepare_result(MYSQL_STMT *stmt)
3830 3831
{
  uchar *pos;
3832
  uint field_count;
unknown's avatar
unknown committed
3833
  ulong length, param_count;
3834
  MYSQL_DATA *fields_data;
unknown's avatar
unknown committed
3835
  MYSQL *mysql= stmt->mysql;
3836
  DBUG_ENTER("read_prepare_result");
3837

3838 3839 3840
  mysql= mysql->last_used_con;
  if ((length= net_safe_read(mysql)) == packet_error)
    DBUG_RETURN(1);
3841

3842
  pos= (uchar*) mysql->net.read_pos;
unknown's avatar
unknown committed
3843 3844 3845
  stmt->stmt_id= uint4korr(pos); pos+=4;
  field_count=   uint2korr(pos); pos+=2;
  param_count=   uint2korr(pos); pos+=2;
3846

3847 3848 3849 3850
  if (field_count != 0)
  {
    if (!(mysql->server_status & SERVER_STATUS_AUTOCOMMIT))
      mysql->server_status|= SERVER_STATUS_IN_TRANS;
3851

3852 3853 3854 3855 3856 3857 3858 3859 3860 3861
    mysql->extra_info= net_field_length_ll(&pos);
    if (!(fields_data= read_rows(mysql, (MYSQL_FIELD*) 0, 8)))
      DBUG_RETURN(1);
    if (!(stmt->fields= unpack_fields(fields_data,&stmt->mem_root,
				      field_count,0,
				      mysql->server_capabilities)))
      DBUG_RETURN(1);
  }
  if (!(stmt->params= (MYSQL_BIND *) alloc_root(&stmt->mem_root,
						sizeof(MYSQL_BIND)*
3862 3863
                                                (param_count + 
                                                 field_count))))
3864
  {
3865
    set_stmt_error(stmt, CR_OUT_OF_MEMORY);
3866 3867
    DBUG_RETURN(0);
  }
3868 3869 3870 3871
  stmt->bind=	      (stmt->params + param_count);
  stmt->field_count=  (uint) field_count;
  stmt->param_count=  (ulong) param_count;
  mysql->status=      MYSQL_STATUS_READY;
3872 3873 3874 3875 3876
  DBUG_RETURN(0);
}


/*
3877 3878 3879 3880 3881
  Prepare the query and return the new statement handle to
  caller.

  Also update the total parameter count along with resultset
  metadata information by reading from server
3882 3883
*/

3884 3885 3886

MYSQL_STMT *STDCALL
mysql_prepare(MYSQL  *mysql, const char *query, ulong length)
3887 3888
{
  MYSQL_STMT  *stmt;
unknown's avatar
unknown committed
3889
  DBUG_ENTER("mysql_prepare");
3890 3891
  DBUG_ASSERT(mysql != 0);

unknown's avatar
unknown committed
3892
#ifdef CHECK_EXTRA_ARGUMENTS
3893 3894 3895 3896 3897 3898 3899
  if (!query)
  {
    set_mysql_error(mysql, CR_NULL_POINTER);
    DBUG_RETURN(0);
  }
#endif

3900 3901 3902 3903 3904 3905
  if (!(stmt= (MYSQL_STMT *) my_malloc(sizeof(MYSQL_STMT),
				       MYF(MY_WME | MY_ZEROFILL))) ||
      !(stmt->query= my_strdup_with_length((byte *) query, length, MYF(0))))
  {
    my_free((gptr) stmt, MYF(MY_ALLOW_ZERO_PTR));
    set_mysql_error(mysql, CR_OUT_OF_MEMORY);
3906
    DBUG_RETURN(0);
3907 3908 3909
  }
  if (simple_command(mysql, COM_PREPARE, query, length, 1))
  {
unknown's avatar
unknown committed
3910
    stmt_close(stmt, 1);
3911 3912 3913
    DBUG_RETURN(0);
  }

3914
  init_alloc_root(&stmt->mem_root,8192,0);
unknown's avatar
unknown committed
3915 3916
  stmt->mysql= mysql;
  if (read_prepare_result(stmt))
3917
  {
unknown's avatar
unknown committed
3918
    stmt_close(stmt, 1);
3919 3920
    DBUG_RETURN(0);
  }
unknown's avatar
unknown committed
3921
  stmt->state= MY_ST_PREPARE;
unknown's avatar
unknown committed
3922 3923
  mysql->stmts= list_add(mysql->stmts, &stmt->list);
  stmt->list.data= stmt;
3924 3925 3926 3927 3928 3929 3930
  DBUG_PRINT("info", ("Parameter count: %ld", stmt->param_count));
  DBUG_RETURN(stmt);
}


/*
  Returns prepared meta information in the form of resultset
3931
  to client.
3932 3933 3934 3935 3936 3937 3938
*/

MYSQL_RES * STDCALL
mysql_prepare_result(MYSQL_STMT *stmt)
{
  MYSQL_RES *result;
  DBUG_ENTER("mysql_prepare_result");
unknown's avatar
unknown committed
3939 3940
  
  if (!stmt->field_count || !stmt->fields)
3941
    DBUG_RETURN(0);
unknown's avatar
unknown committed
3942 3943 3944 3945 3946 3947
  
  if (!(result=(MYSQL_RES*) my_malloc(sizeof(*result)+
				      sizeof(ulong)*stmt->field_count,
				      MYF(MY_WME | MY_ZEROFILL))))
    return 0;

3948 3949 3950 3951
  result->eof=1;	/* Marker for buffered */
  result->fields=	stmt->fields;
  result->field_count=	stmt->field_count;
  DBUG_RETURN(result);
3952 3953
}

3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974
/*
  Returns parameter columns meta information in the form of 
  resultset.
*/

MYSQL_RES * STDCALL
mysql_param_result(MYSQL_STMT *stmt)
{
  DBUG_ENTER("mysql_param_result");
  
  if (!stmt->param_count)
    DBUG_RETURN(0);

  /*
    TODO: Fix this when server sends the information. 
    Till then keep a dummy prototype 
  */
  DBUG_RETURN(0); 
}


3975

3976 3977 3978 3979
/********************************************************************
 Prepare-execute, and param handling
*********************************************************************/

3980 3981
/*
  Store the buffer type
3982 3983
*/

3984
static void store_param_type(NET *net, uint type)
3985
{
3986 3987
  int2store(net->write_pos, type);
  net->write_pos+=2;
3988 3989
}

3990
/*
3991
  Store the length of parameter data
3992
  (Same function as in sql/net_pkg.cc)
3993
*/
3994 3995 3996

char *
net_store_length(char *pkg, ulong length)
3997 3998 3999 4000 4001 4002 4003
{
  uchar *packet=(uchar*) pkg;
  if (length < 251)
  {
    *packet=(uchar) length;
    return (char*) packet+1;
  }
4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019
  /* 251 is reserved for NULL */
  if (length < 65536L)
  {
    *packet++=252;
    int2store(packet,(uint) length);
    return (char*) packet+2;
  }
  if (length < 16777216L)
  {
    *packet++=253;
    int3store(packet,(ulong) length);
    return (char*) packet+3;
  }
  *packet++=254;
  int8store(packet, (ulonglong) length);
  return (char*) packet+9;
4020 4021 4022
}


4023 4024
/****************************************************************************
  Functions to store parameter data from a prepared statement.
4025

4026
  All functions has the following characteristics:
4027

4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041
  SYNOPSIS
    store_param_xxx()
    net			MySQL NET connection
    param		MySQL bind param

  RETURN VALUES
    0	ok
    1	Error	(Can't alloc net->buffer)
****************************************************************************/


static void store_param_tinyint(NET *net, MYSQL_BIND *param)
{
  *(net->write_pos++)= (uchar) *param->buffer;
4042 4043
}

4044 4045 4046 4047 4048 4049
static void store_param_short(NET *net, MYSQL_BIND *param)
{
  short value= *(short*) param->buffer;
  int2store(net->write_pos,value);
  net->write_pos+=2;
}
4050

4051
static void store_param_int32(NET *net, MYSQL_BIND *param)
4052
{
4053 4054 4055 4056
  int32 value= *(int32*) param->buffer;
  int4store(net->write_pos,value);
  net->write_pos+=4;
}
4057

4058 4059 4060 4061 4062 4063
static void store_param_int64(NET *net, MYSQL_BIND *param)
{
  longlong value= *(longlong*) param->buffer;
  int8store(net->write_pos,value);
  net->write_pos+= 8;
}
4064

4065 4066 4067 4068 4069
static void store_param_float(NET *net, MYSQL_BIND *param)
{
  float value= *(float*) param->buffer;
  float4store(net->write_pos, value);
  net->write_pos+= 4;
4070 4071
}

4072 4073 4074 4075 4076 4077
static void store_param_double(NET *net, MYSQL_BIND *param)
{
  double value= *(double*) param->buffer;
  float8store(net->write_pos, value);
  net->write_pos+= 8;
}
4078

unknown's avatar
unknown committed
4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143
static void store_param_time(NET *net, MYSQL_BIND *param)
{
  MYSQL_TIME *tm= (MYSQL_TIME *) param->buffer;
  char buff[15], *pos;
  uint length;

  pos= buff+1;
  pos[0]= tm->neg ? 1: 0;
  int4store(pos+1, tm->day);
  pos[5]= (uchar) tm->hour;
  pos[6]= (uchar) tm->minute;
  pos[7]= (uchar) tm->second;
  int4store(pos+8, tm->second_part);
  if (tm->second_part)
    length= 11;
  else if (tm->hour || tm->minute || tm->second || tm->day)
    length= 8;
  else
    length= 0;
  buff[0]= (char) length++;  
  memcpy((char *)net->write_pos, buff, length);
  net->write_pos+= length;
}

static void net_store_datetime(NET *net, MYSQL_TIME *tm)
{
  char buff[12], *pos;
  uint length;

  pos= buff+1;

  int2store(pos, tm->year);
  pos[2]= (uchar) tm->month;
  pos[3]= (uchar) tm->day;
  pos[4]= (uchar) tm->hour;
  pos[5]= (uchar) tm->minute;
  pos[6]= (uchar) tm->second;
  int4store(pos+7, tm->second_part);
  if (tm->second_part)
    length= 11;
  else if (tm->hour || tm->minute || tm->second)
    length= 7;
  else if (tm->year || tm->month || tm->day)
    length= 4;
  else
    length= 0;
  buff[0]= (char) length++;  
  memcpy((char *)net->write_pos, buff, length);
  net->write_pos+= length;
}

static void store_param_date(NET *net, MYSQL_BIND *param)
{
  MYSQL_TIME *tm= (MYSQL_TIME *) param->buffer;
  tm->hour= tm->minute= tm->second= 0;
  tm->second_part= 0;
  net_store_datetime(net, tm);
}

static void store_param_datetime(NET *net, MYSQL_BIND *param)
{
  MYSQL_TIME *tm= (MYSQL_TIME *) param->buffer;
  net_store_datetime(net, tm);
}
    
4144
static void store_param_str(NET *net, MYSQL_BIND *param)
4145
{
4146
  ulong length= min(*param->length, param->buffer_length);
4147 4148
  char *to= (char *) net_store_length((char *) net->write_pos, length);
  memcpy(to, param->buffer, length);
unknown's avatar
unknown committed
4149
  net->write_pos= (uchar*) to+length;
4150 4151
}

4152

4153
/*
4154 4155 4156 4157 4158 4159 4160 4161 4162 4163
  Mark if the parameter is NULL.

  SYNOPSIS
    store_param_null()
    net			MySQL NET connection
    param		MySQL bind param

  DESCRIPTION
    A data package starts with a string of bits where we set a bit
    if a parameter is NULL
4164 4165
*/

4166
static void store_param_null(NET *net, MYSQL_BIND *param)
4167
{
4168 4169 4170
  uint pos= param->param_number;
  (uchar) net->buff[pos/8]|=  (1 << pos & 7);
}
4171 4172 4173 4174


/*
  Set parameter data by reading from input buffers from the
4175
  client application
4176 4177
*/

unknown's avatar
unknown committed
4178

4179
static my_bool store_param(MYSQL_STMT *stmt, MYSQL_BIND *param)
4180
{
4181 4182 4183
  MYSQL *mysql= stmt->mysql;
  NET	*net  = &mysql->net;
  DBUG_ENTER("store_param");
unknown's avatar
unknown committed
4184 4185 4186 4187 4188 4189
  DBUG_PRINT("enter",("type: %d, buffer:%lx, length: %lu  is_null: %d",
		      param->buffer_type,
		      param->buffer ? param->buffer : "0", *param->length,
		      *param->is_null));

  if (*param->is_null)
4190 4191
    store_param_null(net, param);
  else
unknown's avatar
unknown committed
4192
  {
unknown's avatar
unknown committed
4193 4194
    /*
      Param->length should ALWAYS point to the correct length for the type
4195
      Either to the length pointer given by the user or param->buffer_length
unknown's avatar
unknown committed
4196 4197
    */
    if ((my_realloc_str(net, 9 + *param->length)))
unknown's avatar
unknown committed
4198 4199
    {
      set_stmt_error(stmt, CR_OUT_OF_MEMORY);
unknown's avatar
unknown committed
4200
      DBUG_RETURN(1);
unknown's avatar
unknown committed
4201
    }
4202
    (*param->store_param_func)(net, param);
unknown's avatar
unknown committed
4203 4204
  }
  DBUG_RETURN(0);
4205 4206
}

unknown's avatar
unknown committed
4207

4208 4209 4210 4211
/*
  Send the prepare query to server for execution
*/

4212
static my_bool execute(MYSQL_STMT * stmt, char *packet, ulong length)
4213
{
4214 4215
  MYSQL *mysql= stmt->mysql;
  NET	*net= &mysql->net;
unknown's avatar
unknown committed
4216
  char buff[MYSQL_STMT_HEADER];
4217
  DBUG_ENTER("execute");
4218 4219
  DBUG_PRINT("enter",("packet: %s, length :%d",packet ? packet :" ", length));

4220 4221
  mysql->last_used_con= mysql;
  int4store(buff, stmt->stmt_id);		/* Send stmt id to server */
unknown's avatar
unknown committed
4222
  if (advanced_command(mysql, COM_EXECUTE, buff, MYSQL_STMT_HEADER, packet,
4223
		       length, 1) ||
4224 4225 4226
      mysql_read_query_result(mysql))
  {
    set_stmt_errmsg(stmt, net->last_error, net->last_errno);
4227
    DBUG_RETURN(1);
4228
  }
4229
  stmt->state= MY_ST_EXECUTE;
unknown's avatar
unknown committed
4230
  mysql_free_result(stmt->result);
4231 4232
  stmt->result= (MYSQL_RES *)0;
  stmt->result_buffered= 0;
4233 4234 4235
  DBUG_RETURN(0);
}

4236 4237 4238

/*
  Execute the prepare query
4239 4240
*/

4241
int STDCALL mysql_execute(MYSQL_STMT *stmt)
4242 4243 4244 4245 4246 4247
{
  DBUG_ENTER("mysql_execute");

  if (stmt->state == MY_ST_UNKNOWN)
  {
    set_stmt_error(stmt, CR_NO_PREPARE_STMT);
4248
    DBUG_RETURN(1);
4249
  }
4250
  stmt->mysql->fields= stmt->fields;
4251 4252
  if (stmt->param_count)
  {
4253 4254
    NET        *net= &stmt->mysql->net;
    MYSQL_BIND *param, *param_end;
4255
    char       *param_data;
unknown's avatar
unknown committed
4256 4257 4258
    ulong length;
    uint null_count;
    my_bool    result;
4259

unknown's avatar
unknown committed
4260 4261
#ifdef CHECK_EXTRA_ARGUMENTS
    if (!stmt->param_buffers)
4262 4263 4264
    {
      /* Parameters exists, but no bound buffers */
      set_stmt_error(stmt, CR_NOT_ALL_PARAMS_BOUND);
4265
      DBUG_RETURN(1);
4266
    }
unknown's avatar
unknown committed
4267
#endif
4268 4269 4270 4271 4272 4273 4274 4275
    net_clear(net);				/* Sets net->write_pos */
    /* Reserve place for null-marker bytes */
    null_count= (stmt->param_count+7) /8;
    bzero((char*) net->write_pos, null_count);
    net->write_pos+= null_count;
    param_end= stmt->params + stmt->param_count;

    /* In case if buffers (type) altered, indicate to server */
unknown's avatar
unknown committed
4276 4277
    *(net->write_pos)++= (uchar) stmt->send_types_to_server;
    if (stmt->send_types_to_server)
4278
    {
4279 4280 4281 4282 4283 4284 4285 4286 4287
      /*
	Store types of parameters in first in first package
	that is sent to the server.
      */
      for (param= stmt->params;	param < param_end ; param++)
	store_param_type(net, (uint) param->buffer_type);
    }

    for (param= stmt->params; param < param_end; param++)
4288
    {
unknown's avatar
unknown committed
4289 4290 4291
      /* check if mysql_long_data() was used */
      if (param->long_data_used)
	param->long_data_used= 0;	/* Clear for next execute call */
4292
      else if (store_param(stmt, param))
unknown's avatar
unknown committed
4293
	DBUG_RETURN(1);
4294
    }
4295 4296
    length= (ulong) (net->write_pos - net->buff);
    /* TODO: Look into avoding the following memdup */
unknown's avatar
unknown committed
4297
    if (!(param_data= my_memdup((const char*) net->buff, length, MYF(0))))
4298 4299 4300
    {
      set_stmt_error(stmt, CR_OUT_OF_MEMORY);
      DBUG_RETURN(1);
4301
    }
4302 4303
    net->write_pos= net->buff;			/* Reset for net_write() */
    result= execute(stmt, param_data, length);
unknown's avatar
unknown committed
4304
    stmt->send_types_to_server=0;
4305
    my_free(param_data, MYF(MY_WME));
4306 4307 4308
    DBUG_RETURN(result);
  }
  DBUG_RETURN((int) execute(stmt,0,0));
4309 4310
}

4311

4312 4313 4314 4315 4316 4317 4318 4319 4320 4321
/*
  Return total parameters count in the statement
*/

ulong STDCALL mysql_param_count(MYSQL_STMT * stmt)
{
  DBUG_ENTER("mysql_param_count");
  DBUG_RETURN(stmt->param_count);
}

4322 4323 4324 4325 4326 4327 4328 4329
/*
  Return total affected rows from the last statement
*/

my_ulonglong STDCALL mysql_stmt_affected_rows(MYSQL_STMT *stmt)
{
  return stmt->mysql->last_used_con->affected_rows;
}
4330

unknown's avatar
unknown committed
4331 4332 4333 4334 4335

static my_bool int_is_null_true= 1;		/* Used for MYSQL_TYPE_NULL */
static my_bool int_is_null_false= 0;
static my_bool int_is_null_dummy;

4336
/*
4337
  Setup the parameter data buffers from application
4338 4339
*/

4340
my_bool STDCALL mysql_bind_param(MYSQL_STMT *stmt, MYSQL_BIND * bind)
4341
{
4342 4343
  uint count=0;
  MYSQL_BIND *param, *end;
4344 4345 4346 4347 4348 4349
  DBUG_ENTER("mysql_bind_param");

#ifdef CHECK_EXTRA_ARGUMENTS
  if (stmt->state == MY_ST_UNKNOWN)
  {
    set_stmt_error(stmt, CR_NO_PREPARE_STMT);
4350
    DBUG_RETURN(1);
4351 4352 4353 4354
  }
  if (!stmt->param_count)
  {
    set_stmt_error(stmt, CR_NO_PARAMETERS_EXISTS);
4355
    DBUG_RETURN(1);
4356 4357 4358
  }
#endif

4359 4360 4361 4362 4363 4364 4365
  /* Allocated on prepare */
  memcpy((char*) stmt->params, (char*) bind,
	 sizeof(MYSQL_BIND) * stmt->param_count);

  for (param= stmt->params, end= param+stmt->param_count;
       param < end ;
       param++)
4366
  {
4367
    param->param_number= count++;
4368 4369
    param->long_data_used= 0;

4370
    /*
4371
      If param->length is not given, change it to point to buffer_length.
4372 4373 4374
      This way we can always use *param->length to get the length of data
    */
    if (!param->length)
4375
      param->length= &param->buffer_length;
unknown's avatar
unknown committed
4376

unknown's avatar
unknown committed
4377 4378 4379 4380
    /* If param->is_null is not set, then the value can never be NULL */
    if (!param->is_null)
      param->is_null= &int_is_null_false;

4381 4382
    /* Setup data copy functions for the different supported types */
    switch (param->buffer_type) {
unknown's avatar
unknown committed
4383
    case MYSQL_TYPE_NULL:
unknown's avatar
unknown committed
4384
      param->is_null= &int_is_null_true;
unknown's avatar
unknown committed
4385
      break;
4386
    case MYSQL_TYPE_TINY:
unknown's avatar
unknown committed
4387
      /* Force param->length as this is fixed for this type */
4388 4389
      param->length= &param->buffer_length;
      param->buffer_length= 1;
4390 4391 4392
      param->store_param_func= store_param_tinyint;
      break;
    case MYSQL_TYPE_SHORT:
4393 4394
      param->length= &param->buffer_length;
      param->buffer_length= 2;
4395 4396 4397
      param->store_param_func= store_param_short;
      break;
    case MYSQL_TYPE_LONG:
4398 4399
      param->length= &param->buffer_length;
      param->buffer_length= 4;
4400 4401 4402
      param->store_param_func= store_param_int32;
      break;
    case MYSQL_TYPE_LONGLONG:
4403 4404
      param->length= &param->buffer_length;
      param->buffer_length= 8;
4405 4406 4407
      param->store_param_func= store_param_int64;
      break;
    case MYSQL_TYPE_FLOAT:
4408 4409
      param->length= &param->buffer_length;
      param->buffer_length= 4;
4410 4411 4412
      param->store_param_func= store_param_float;
      break;
    case MYSQL_TYPE_DOUBLE:
4413 4414
      param->length= &param->buffer_length;
      param->buffer_length= 8;
4415 4416
      param->store_param_func= store_param_double;
      break;
unknown's avatar
unknown committed
4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427
    case MYSQL_TYPE_TIME:
      /* Buffer length ignored for DATE, TIME and DATETIME */
      param->store_param_func= store_param_time;
      break;
    case MYSQL_TYPE_DATE:
      param->store_param_func= store_param_date;
      break;
    case MYSQL_TYPE_DATETIME:
    case MYSQL_TYPE_TIMESTAMP:
      param->store_param_func= store_param_datetime;
      break;
4428 4429 4430
    case MYSQL_TYPE_TINY_BLOB:
    case MYSQL_TYPE_MEDIUM_BLOB:
    case MYSQL_TYPE_LONG_BLOB:
unknown's avatar
unknown committed
4431
    case MYSQL_TYPE_BLOB:
4432 4433 4434 4435 4436
    case MYSQL_TYPE_VAR_STRING:
    case MYSQL_TYPE_STRING:
      param->store_param_func= store_param_str;
      break;
    default:
unknown's avatar
unknown committed
4437 4438
      sprintf(stmt->last_error,
	      ER(stmt->last_errno= CR_UNSUPPORTED_PARAM_TYPE),
4439 4440
	      param->buffer_type, param->param_number);
      DBUG_RETURN(1);
4441 4442
    }
  }
4443
  /* We have to send/resendtype information to MySQL */
unknown's avatar
unknown committed
4444 4445
  stmt->send_types_to_server= 1;
  stmt->param_buffers= 1;
4446 4447 4448
  DBUG_RETURN(0);
}

4449

4450 4451 4452 4453 4454
/********************************************************************
 Long data implementation
*********************************************************************/

/*
4455 4456 4457 4458 4459 4460 4461 4462
  Send long data in pieces to the server

  SYNOPSIS
    mysql_send_long_data()
    stmt			Statement handler
    param_number		Parameter number (0 - N-1)
    data			Data to send to server
    length			Length of data to send (may be 0)
unknown's avatar
unknown committed
4463

4464
  RETURN VALUES
unknown's avatar
unknown committed
4465 4466
    0	ok
    1	error
4467 4468 4469
*/


4470 4471
my_bool STDCALL
mysql_send_long_data(MYSQL_STMT *stmt, uint param_number,
unknown's avatar
unknown committed
4472
		     const char *data, ulong length)
4473 4474 4475
{
  MYSQL_BIND *param;
  DBUG_ENTER("mysql_send_long_data");
4476
  DBUG_ASSERT(stmt != 0);
4477
  DBUG_PRINT("enter",("param no : %d, data : %lx, length : %ld",
4478
		      param_number, data, length));
4479

4480
  if (param_number >= stmt->param_count)
4481 4482 4483 4484
  {
    set_stmt_error(stmt, CR_INVALID_PARAMETER_NO);
    DBUG_RETURN(1);
  }
4485
  param= stmt->params+param_number;
unknown's avatar
unknown committed
4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498
  if (param->buffer_type < MYSQL_TYPE_TINY_BLOB ||
      param->buffer_type > MYSQL_TYPE_STRING)
  {
    /*
      Long data handling should be used only for string/binary
      types only
    */
    sprintf(stmt->last_error, ER(stmt->last_errno= CR_INVALID_BUFFER_USE),
	    param->param_number);
    DBUG_RETURN(1);
  }
  /* Mark for execute that the result is already sent */
  param->long_data_used= 1;
4499
  if (length)
4500
  {
4501 4502 4503 4504 4505 4506
    MYSQL *mysql= stmt->mysql;
    char   *packet, extra_data[MYSQL_LONG_DATA_HEADER];

    packet= extra_data;
    int4store(packet, stmt->stmt_id);	   packet+=4;
    int2store(packet, param_number);	   packet+=2;
4507

4508 4509 4510 4511 4512 4513
    /*
      Note that we don't get any ok packet from the server in this case
      This is intentional to save bandwidth.
    */
    if (advanced_command(mysql, COM_LONG_DATA, extra_data,
			 MYSQL_LONG_DATA_HEADER, data, length, 1))
4514
    {
4515 4516
      set_stmt_errmsg(stmt,(char *) mysql->net.last_error,
		      mysql->net.last_errno);
4517 4518 4519 4520 4521 4522
      DBUG_RETURN(1);
    }
  }
  DBUG_RETURN(0);
}

4523

4524
/********************************************************************
4525
  Fetch-bind related implementations
4526 4527
*********************************************************************/

unknown's avatar
unknown committed
4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542
/****************************************************************************
  Functions to fetch data to application buffers

  All functions has the following characteristics:

  SYNOPSIS
    fetch_result_xxx()
    param   MySQL bind param
    row     Row value

  RETURN VALUES
    0	ok
    1	Error	(Can't alloc net->buffer)
****************************************************************************/

unknown's avatar
unknown committed
4543
static void set_zero_time(MYSQL_TIME *tm)
4544
{
unknown's avatar
unknown committed
4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615
  tm->year= tm->month= tm->day= 0;
  tm->hour= tm->minute= tm->second= 0;
  tm->second_part= 0;
  tm->neg= (bool)0;
}

/* Read TIME from binary packet and return it to MYSQL_TIME */
static uint read_binary_time(MYSQL_TIME *tm, uchar **pos)
{
  uchar *to;
  uint  length;
 
  if (!(length= net_field_length(pos)))
  {
    set_zero_time(tm);
    return 0;
  }
  
  to= *pos;     
  tm->second_part= (length > 8 ) ? (ulong) sint4korr(to+7): 0;

  tm->day=    (ulong) sint4korr(to+1);
  tm->hour=   (uint) to[5];
  tm->minute= (uint) to[6];
  tm->second= (uint) to[7];

  tm->year= tm->month= 0;
  tm->neg= (bool)to[0];
  return length;
}

/* Read DATETIME from binary packet and return it to MYSQL_TIME */
static uint read_binary_datetime(MYSQL_TIME *tm, uchar **pos)
{
  uchar *to;
  uint  length;
 
  if (!(length= net_field_length(pos)))
  {
    set_zero_time(tm);
    return 0;
  }
  
  to= *pos;     
  tm->second_part= (length > 7 ) ? (ulong) sint4korr(to+7): 0;
    
  if (length > 4)
  {
    tm->hour=   (uint) to[4];
    tm->minute= (uint) to[5];
    tm->second= (uint) to[6];
  }
  else
    tm->hour= tm->minute= tm->second= 0;
    
  tm->year=   (uint) sint2korr(to);
  tm->month=  (uint) to[2];
  tm->day=    (uint) to[3];
  tm->neg=    0;
  return length;
}

/* Read DATE from binary packet and return it to MYSQL_TIME */
static uint read_binary_date(MYSQL_TIME *tm, uchar **pos)
{
  uchar *to;
  uint  length;
 
  if (!(length= net_field_length(pos)))
  {
    set_zero_time(tm);
4616
    return 0;
4617
  }
unknown's avatar
unknown committed
4618 4619 4620 4621 4622 4623 4624 4625 4626 4627
  
  to= *pos;     
  tm->year =  (uint) sint2korr(to);
  tm->month=  (uint) to[2];
  tm->day= (uint) to[3];

  tm->hour= tm->minute= tm->second= 0;
  tm->second_part= 0;
  tm->neg= 0;
  return length;
4628 4629
}

4630
/* Convert Numeric to buffer types */
4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661
static void send_data_long(MYSQL_BIND *param, longlong value)
{  
  char *buffer= param->buffer;
  
  switch(param->buffer_type) {
  case MYSQL_TYPE_TINY:
    *param->buffer= (uchar) value;
    break;
  case MYSQL_TYPE_SHORT:
    int2store(buffer, (short)value);
    break;
  case MYSQL_TYPE_LONG:
    int4store(buffer, (int32)value);
    break;
  case MYSQL_TYPE_LONGLONG:
    int8store(buffer, (longlong)value);
    break;
  case MYSQL_TYPE_FLOAT:
    {
      float data= (float)value;
      float4store(buffer, data);
      break;
    }
  case MYSQL_TYPE_DOUBLE:
    {
      double data= (double)value;
      float8store(buffer, data);
      break;
    }
  default:
    {
4662
      uint length= (uint)(longlong10_to_str(value,buffer,10)-buffer);
4663 4664 4665 4666 4667 4668
      *param->length= length;
      buffer[length]='\0';
    }
  } 
}

4669

4670
/* Convert Double to buffer types */
4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701
static void send_data_double(MYSQL_BIND *param, double value)
{  
  char *buffer= param->buffer;

  switch(param->buffer_type) {
  case MYSQL_TYPE_TINY:
    *buffer= (uchar)value;
    break;
  case MYSQL_TYPE_SHORT:
    int2store(buffer, (short)value);
    break;
  case MYSQL_TYPE_LONG:
    int4store(buffer, (int32)value);
    break;
  case MYSQL_TYPE_LONGLONG:
    int8store(buffer, (longlong)value);
    break;
  case MYSQL_TYPE_FLOAT:
    {
      float data= (float)value;
      float4store(buffer, data);
      break;
    }
  case MYSQL_TYPE_DOUBLE:
    {
      double data= (double)value;
      float8store(buffer, data);
      break;
    }
  default:
    {
4702
      uint length= my_sprintf(buffer,(buffer,"%g",value));
4703 4704 4705 4706 4707 4708
      *param->length= length;
      buffer[length]='\0';
    }
  } 
}

4709 4710
/* Convert string to buffer types */
static void send_data_str(MYSQL_BIND *param, char *value, uint length)
4711 4712
{  
  char *buffer= param->buffer;
4713
  int err=0;
4714 4715 4716

  switch(param->buffer_type) {
  case MYSQL_TYPE_TINY:
4717
  {
unknown's avatar
unknown committed
4718 4719
    uchar data= (uchar)my_strntol(system_charset_info,value,length,10,NULL,
				  &err);
4720
    *buffer= data;
4721
    break;
4722
  }
4723 4724
  case MYSQL_TYPE_SHORT:
  {
unknown's avatar
unknown committed
4725 4726
    short data= (short)my_strntol(system_charset_info,value,length,10,NULL,
				  &err);
4727 4728 4729 4730 4731
    int2store(buffer, data);
    break;
  }
  case MYSQL_TYPE_LONG:
  {
unknown's avatar
unknown committed
4732 4733
    int32 data= (int32)my_strntol(system_charset_info,value,length,10,NULL,
				  &err);
4734 4735 4736 4737 4738
    int4store(buffer, data);    
    break;
  }
  case MYSQL_TYPE_LONGLONG:
  {
4739
    longlong data= my_strntoll(system_charset_info,value,length,10,NULL,&err);
4740 4741 4742 4743 4744
    int8store(buffer, data);
    break;
  }
  case MYSQL_TYPE_FLOAT:
  {
4745
    float data = (float)my_strntod(system_charset_info,value,length,NULL,&err);
4746 4747 4748 4749 4750
    float4store(buffer, data);
    break;
  }
  case MYSQL_TYPE_DOUBLE:
  {
4751
    double data= my_strntod(system_charset_info,value,length,NULL,&err);
4752 4753 4754 4755
    float8store(buffer, data);
    break;
  }
  default:
4756
    *param->length= length;
4757
    length= min(length, param->buffer_length);
4758
    memcpy(buffer, value, length);
4759 4760
    if (length != param->buffer_length)
      buffer[length]='\0';
4761 4762 4763
  } 
}

unknown's avatar
unknown committed
4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817
static void send_data_time(MYSQL_BIND *param, MYSQL_TIME ltime, 
                           uint length)
{
  switch (param->buffer_type) {

  case MYSQL_TYPE_DATE:
  case MYSQL_TYPE_TIME:
  case MYSQL_TYPE_DATETIME:
  case MYSQL_TYPE_TIMESTAMP:
  {
    MYSQL_TIME *tm= (MYSQL_TIME *)param->buffer;
    
    tm->year= ltime.year;
    tm->month= ltime.month;
    tm->day= ltime.day;

    tm->hour= ltime.hour;
    tm->minute= ltime.minute;
    tm->second= ltime.second;

    tm->second_part= ltime.second_part;
    tm->neg= ltime.neg;
    break;   
  }
  default:
  {
    char buff[25];
    
    if (!length)
      ltime.time_type= MYSQL_TIMESTAMP_NONE;
    switch (ltime.time_type) {
    case MYSQL_TIMESTAMP_DATE:
      length= my_sprintf(buff,(buff, "%04d-%02d-%02d", ltime.year,
                         ltime.month,ltime.day));      
      break;
    case MYSQL_TIMESTAMP_FULL:
      length= my_sprintf(buff,(buff, "%04d-%02d-%02d %02d:%02d:%02d",
	                       ltime.year,ltime.month,ltime.day,
	                       ltime.hour,ltime.minute,ltime.second));
      break;
    case MYSQL_TIMESTAMP_TIME:
      length= my_sprintf(buff, (buff, "%02d:%02d:%02d",
	                 	     ltime.hour,ltime.minute,ltime.second));
      break;
    default:
      length= 0;
      buff[0]='\0';
    }
    send_data_str(param, (char *)buff, length); 
  }
  }
}
                              

unknown's avatar
unknown committed
4818

4819
/* Fetch data to buffers */
unknown's avatar
unknown committed
4820
static void fetch_results(MYSQL_BIND *param, uint field_type, uchar **row)
4821 4822
{
  ulong length;
4823
  
4824 4825 4826 4827 4828
  switch (field_type) {
  case MYSQL_TYPE_TINY:
  {
    uchar value= (uchar) **row;
    send_data_long(param,(longlong)value);
unknown's avatar
unknown committed
4829
    length= 1;
4830 4831 4832 4833 4834 4835 4836
    break;
  }
  case MYSQL_TYPE_SHORT:
  case MYSQL_TYPE_YEAR:
  {
    short value= (short)sint2korr(*row);
    send_data_long(param,(longlong)value);
unknown's avatar
unknown committed
4837
    length= 2;
4838 4839 4840 4841 4842 4843
    break;
  }
  case MYSQL_TYPE_LONG:
  {
    int32 value= (int32)sint4korr(*row);
    send_data_long(param,(int32)value);
unknown's avatar
unknown committed
4844
    length= 4;
4845 4846 4847 4848 4849 4850
    break;
  }
  case MYSQL_TYPE_LONGLONG:
  {
    longlong value= (longlong)sint8korr(*row);
    send_data_long(param,value);
unknown's avatar
unknown committed
4851
    length= 8;
4852 4853 4854 4855 4856 4857 4858
    break;
  }
  case MYSQL_TYPE_FLOAT:
  {
    float value;
    float4get(value,*row);
    send_data_double(param,(double)value);
unknown's avatar
unknown committed
4859
    length= 4;
4860 4861 4862 4863 4864 4865 4866
    break;
  }
  case MYSQL_TYPE_DOUBLE:
  {
    double value;
    float8get(value,*row);
    send_data_double(param,(double)value);
unknown's avatar
unknown committed
4867
    length= 8;
4868 4869 4870 4871
    break;
  }
  case MYSQL_TYPE_DATE:
  {
unknown's avatar
unknown committed
4872 4873 4874 4875 4876
    MYSQL_TIME tm;
 
    length= read_binary_date(&tm,row);
    tm.time_type= MYSQL_TIMESTAMP_DATE;
    send_data_time(param, tm, length);
4877 4878 4879 4880
    break;
  }
  case MYSQL_TYPE_TIME:
  {
unknown's avatar
unknown committed
4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895
    MYSQL_TIME tm;
 
    length= read_binary_time(&tm, row);
    tm.time_type= MYSQL_TIMESTAMP_TIME;
    send_data_time(param, tm, length);
    break;
  }
  case MYSQL_TYPE_DATETIME:
  case MYSQL_TYPE_TIMESTAMP:
  {
    MYSQL_TIME tm;
 
    length= read_binary_datetime(&tm, row);
    tm.time_type= MYSQL_TIMESTAMP_FULL;
    send_data_time(param, tm, length);
4896 4897 4898 4899
    break;
  }
  default:      
    length= net_field_length(row); 
unknown's avatar
unknown committed
4900
    send_data_str(param,(char*) *row,length);
4901 4902 4903 4904 4905
    break;
  }
  *row+= length;
}

unknown's avatar
unknown committed
4906 4907 4908
static void fetch_result_tinyint(MYSQL_BIND *param, uchar **row)
{
  *param->buffer= (uchar) **row;
4909
  (*row)++;
unknown's avatar
unknown committed
4910 4911 4912 4913
}

static void fetch_result_short(MYSQL_BIND *param, uchar **row)
{
4914 4915 4916
  short value = (short)sint2korr(*row);
  int2store(param->buffer, value);
  *row+= 2;
unknown's avatar
unknown committed
4917 4918 4919 4920
}

static void fetch_result_int32(MYSQL_BIND *param, uchar **row)
{
4921
  int32 value= (int32)sint4korr(*row);
unknown's avatar
unknown committed
4922
  int4store(param->buffer, value);
4923
  *row+= 4;
unknown's avatar
unknown committed
4924 4925 4926
}

static void fetch_result_int64(MYSQL_BIND *param, uchar **row)
4927 4928
{  
  longlong value= (longlong)sint8korr(*row);
unknown's avatar
unknown committed
4929
  int8store(param->buffer, value);
4930
  *row+= 8;
unknown's avatar
unknown committed
4931 4932 4933 4934 4935 4936
}

static void fetch_result_float(MYSQL_BIND *param, uchar **row)
{
  float value;
  float4get(value,*row);
unknown's avatar
unknown committed
4937
  float4store(param->buffer, value);
4938
  *row+= 4;
unknown's avatar
unknown committed
4939 4940 4941 4942 4943 4944 4945
}

static void fetch_result_double(MYSQL_BIND *param, uchar **row)
{
  double value;
  float8get(value,*row);
  float8store(param->buffer, value);
4946
  *row+= 8;
unknown's avatar
unknown committed
4947 4948
}

unknown's avatar
unknown committed
4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966
static void fetch_result_time(MYSQL_BIND *param, uchar **row)
{
  MYSQL_TIME *tm= (MYSQL_TIME *)param->buffer;
  *row+= read_binary_time(tm, row);
}

static void fetch_result_date(MYSQL_BIND *param, uchar **row)
{
  MYSQL_TIME *tm= (MYSQL_TIME *)param->buffer;
  *row+= read_binary_date(tm, row);
}

static void fetch_result_datetime(MYSQL_BIND *param, uchar **row)
{
  MYSQL_TIME *tm= (MYSQL_TIME *)param->buffer;
  *row+= read_binary_datetime(tm, row);
}

unknown's avatar
unknown committed
4967 4968 4969
static void fetch_result_str(MYSQL_BIND *param, uchar **row)
{
  ulong length= net_field_length(row);
4970 4971
  ulong copy_length= min(length, param->buffer_length);
  memcpy(param->buffer, (char *)*row, copy_length);
4972 4973 4974
  /* Add an end null if there is room in the buffer */
  if (copy_length != param->buffer_length)
    *(param->buffer+copy_length)= '\0';
4975
  *param->length= length; // return total length
4976
  *row+= length;
unknown's avatar
unknown committed
4977 4978
}

4979
/*
4980
  Setup the bind buffers for resultset processing
4981 4982
*/

4983
my_bool STDCALL mysql_bind_result(MYSQL_STMT *stmt, MYSQL_BIND *bind)
4984
{
4985 4986
  MYSQL_BIND *param, *end;
  ulong       bind_count;
4987 4988 4989
  DBUG_ENTER("mysql_bind_result");
  DBUG_ASSERT(stmt != 0);

unknown's avatar
unknown committed
4990
#ifdef CHECK_EXTRA_ARGUMENTS
4991 4992 4993 4994 4995
  if (stmt->state == MY_ST_UNKNOWN)
  {
    set_stmt_error(stmt, CR_NO_PREPARE_STMT);
    DBUG_RETURN(1);
  }
4996 4997 4998
  if (!bind)
  {
    set_stmt_error(stmt, CR_NULL_POINTER);
4999
    DBUG_RETURN(1);
5000
  }
5001
#endif
unknown's avatar
unknown committed
5002
  bind_count= stmt->field_count;
5003 5004
  memcpy((char*) stmt->bind, (char*) bind,
	 sizeof(MYSQL_BIND)*bind_count);
5005

5006
  for (param= stmt->bind, end= param+bind_count; param < end ; param++)
5007
  {
unknown's avatar
unknown committed
5008 5009 5010 5011 5012 5013 5014
    /*
      Set param->is_null to point to a dummy variable if it's not set.
      This is to make the excute code easier
    */
    if (!param->is_null)
      param->is_null= &int_is_null_dummy;

unknown's avatar
unknown committed
5015 5016 5017
    if (!param->length)
      param->length= &param->buffer_length;

unknown's avatar
unknown committed
5018 5019 5020 5021
    /* Setup data copy functions for the different supported types */
    switch (param->buffer_type) {
    case MYSQL_TYPE_TINY:
      param->fetch_result= fetch_result_tinyint;
unknown's avatar
unknown committed
5022
      *param->length= 1;
unknown's avatar
unknown committed
5023 5024 5025
      break;
    case MYSQL_TYPE_SHORT:
      param->fetch_result= fetch_result_short;
unknown's avatar
unknown committed
5026
      *param->length= 2;
unknown's avatar
unknown committed
5027 5028 5029
      break;
    case MYSQL_TYPE_LONG:
      param->fetch_result= fetch_result_int32;
unknown's avatar
unknown committed
5030
      *param->length= 4;
unknown's avatar
unknown committed
5031 5032 5033
      break;
    case MYSQL_TYPE_LONGLONG:
      param->fetch_result= fetch_result_int64;
unknown's avatar
unknown committed
5034
      *param->length= 8;
unknown's avatar
unknown committed
5035 5036 5037
      break;
    case MYSQL_TYPE_FLOAT:
      param->fetch_result= fetch_result_float;
unknown's avatar
unknown committed
5038
      *param->length= 4;
unknown's avatar
unknown committed
5039 5040 5041
      break;
    case MYSQL_TYPE_DOUBLE:
      param->fetch_result= fetch_result_double;
unknown's avatar
unknown committed
5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055
      *param->length= 8;
      break;
    case MYSQL_TYPE_TIME:
      param->fetch_result= fetch_result_time;
      *param->length= sizeof(MYSQL_TIME);
      break;
    case MYSQL_TYPE_DATE:
      param->fetch_result= fetch_result_date;
      *param->length= sizeof(MYSQL_TIME);
      break;
    case MYSQL_TYPE_DATETIME:
    case MYSQL_TYPE_TIMESTAMP:
      param->fetch_result= fetch_result_datetime;
      *param->length= sizeof(MYSQL_TIME);
unknown's avatar
unknown committed
5056 5057 5058 5059
      break;
    case MYSQL_TYPE_TINY_BLOB:
    case MYSQL_TYPE_MEDIUM_BLOB:
    case MYSQL_TYPE_LONG_BLOB:
5060
    case MYSQL_TYPE_BLOB:
unknown's avatar
unknown committed
5061 5062
    case MYSQL_TYPE_VAR_STRING:
    case MYSQL_TYPE_STRING:
unknown's avatar
unknown committed
5063
      DBUG_ASSERT(param->buffer_length != 0);
unknown's avatar
unknown committed
5064 5065 5066
      param->fetch_result= fetch_result_str;
      break;
    default:
unknown's avatar
unknown committed
5067 5068
      sprintf(stmt->last_error,
	      ER(stmt->last_errno= CR_UNSUPPORTED_PARAM_TYPE),
unknown's avatar
unknown committed
5069 5070
	      param->buffer_type, param->param_number);
      DBUG_RETURN(1);
unknown's avatar
unknown committed
5071
    }
5072
  }
unknown's avatar
unknown committed
5073
  stmt->res_buffers= 1;
5074 5075 5076 5077
  DBUG_RETURN(0);
}

/*
5078
  Fetch row data to bind buffers
5079 5080
*/

5081
static int stmt_fetch_row(MYSQL_STMT *stmt, uchar *row)
5082
{
5083
  MYSQL_BIND  *bind, *end;
5084
  MYSQL_FIELD *field, *field_end;
unknown's avatar
unknown committed
5085
  uchar *null_ptr, bit;
5086 5087 5088

  if (!row || !stmt->res_buffers)
    return 0;
unknown's avatar
unknown committed
5089 5090
  
  null_ptr= row; 
unknown's avatar
unknown committed
5091 5092
  row+= (stmt->field_count+9)/8;		/* skip null bits */
  bit= 4;					/* first 2 bits are reserved */
unknown's avatar
unknown committed
5093
  
unknown's avatar
unknown committed
5094
  /* Copy complete row to application buffers */
unknown's avatar
unknown committed
5095
  for (bind= stmt->bind, end= (MYSQL_BIND *) bind + stmt->field_count, 
5096 5097 5098
       field= stmt->fields, 
       field_end= (MYSQL_FIELD *)stmt->fields+stmt->field_count;
       bind < end && field < field_end;
unknown's avatar
unknown committed
5099 5100
       bind++, field++)
  {         
5101
    if (*null_ptr & bit)
unknown's avatar
unknown committed
5102
      *bind->is_null= 1;
5103
    else
5104
    { 
unknown's avatar
unknown committed
5105
      *bind->is_null= 0;
5106 5107
      if (field->type == bind->buffer_type)
        (*bind->fetch_result)(bind, &row);
unknown's avatar
unknown committed
5108 5109
      else 
        fetch_results(bind, field->type, &row);
5110
    }
unknown's avatar
unknown committed
5111
    if (! ((bit<<=1) & 255))
5112
    {
unknown's avatar
unknown committed
5113
      bit= 1;					/* To next byte */
5114
      null_ptr++;
5115 5116 5117 5118 5119 5120
    }
  }
  return 0;
}

/*
5121
  Fetch and return row data to bound buffers, if any
5122 5123
*/

5124
int STDCALL mysql_fetch(MYSQL_STMT *stmt)
5125
{
unknown's avatar
unknown committed
5126
  MYSQL *mysql= stmt->mysql;
5127
  uchar *row;
5128 5129
  DBUG_ENTER("mysql_fetch");

5130 5131
  row= (uchar *)0;
  if (stmt->result_buffered) /* buffered */
5132
  {
5133 5134 5135 5136 5137 5138 5139 5140
    MYSQL_RES *res;
    
    if (!(res= stmt->result) || !res->data_cursor) 
      goto no_data;
    
    row= (uchar *)res->data_cursor->data;
    res->data_cursor= res->data_cursor->next;
    res->current_row= (MYSQL_ROW)row;    
unknown's avatar
unknown committed
5141
  }
5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179
  else /* un-buffered */
  {
    if (packet_error == net_safe_read(mysql))
    {
      set_stmt_errmsg(stmt,(char *)mysql->net.last_error,
                      mysql->net.last_errno);
      DBUG_RETURN(1);
    }
    if (mysql->net.read_pos[0] == 254)
    {
      mysql->status= MYSQL_STATUS_READY;
      goto no_data;
    }
    row= mysql->net.read_pos+1;
  }
  DBUG_RETURN(stmt_fetch_row(stmt, row));

no_data:
  DBUG_PRINT("info", ("end of data"));    
  DBUG_RETURN(MYSQL_NO_DATA); /* no more data */
}

/* 
  Read all rows of data from server  (binary format)
*/

static MYSQL_DATA *read_binary_rows(MYSQL_STMT *stmt)
{
  ulong      pkt_len;
  uchar      *cp;
  MYSQL      *mysql= stmt->mysql;
  MYSQL_DATA *result;
  MYSQL_ROWS *cur, **prev_ptr;
  NET        *net = &mysql->net;
  DBUG_ENTER("read_binary_rows");
 
  mysql= mysql->last_used_con;
  if ((pkt_len= net_safe_read(mysql)) == packet_error)
unknown's avatar
unknown committed
5180
  {
5181 5182
    set_stmt_errmsg(stmt,(char *)mysql->net.last_error,
                    mysql->net.last_errno);
5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239
    DBUG_RETURN(0);
  }
  if (mysql->net.read_pos[0] == 254) /* end of data */
    return 0;				

  if (!(result=(MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
				       MYF(MY_WME | MY_ZEROFILL))))
  {
    net->last_errno=CR_OUT_OF_MEMORY;
    strmov(net->last_error,ER(net->last_errno));
    DBUG_RETURN(0);
  }
  init_alloc_root(&result->alloc,8192,0);	/* Assume rowlength < 8192 */
  result->alloc.min_malloc= sizeof(MYSQL_ROWS);
  prev_ptr= &result->data;
  result->rows= 0;

  while (*(cp=net->read_pos) != 254 || pkt_len >= 8)
  {
    result->rows++;

    if (!(cur= (MYSQL_ROWS*) alloc_root(&result->alloc,sizeof(MYSQL_ROWS))) ||
	      !(cur->data= ((MYSQL_ROW) alloc_root(&result->alloc, pkt_len))))
    {
      free_rows(result);
      net->last_errno=CR_OUT_OF_MEMORY;
      strmov(net->last_error,ER(net->last_errno));
      DBUG_RETURN(0);
    }
    *prev_ptr= cur;
    prev_ptr= &cur->next;
    memcpy(cur->data, (char*)cp+1, pkt_len-1); 
	  
    if ((pkt_len=net_safe_read(mysql)) == packet_error)
    {
      free_rows(result);
      DBUG_RETURN(0);
    }
  }
  *prev_ptr= 0;
  if (pkt_len > 1)
  {
    mysql->warning_count= uint2korr(cp+1);
    DBUG_PRINT("info",("warning_count:  %ld", mysql->warning_count));
  }
  DBUG_PRINT("exit",("Got %d rows",result->rows));
  DBUG_RETURN(result);
}

/*
  Store or buffer the binary results to stmt
*/

int STDCALL mysql_stmt_store_result(MYSQL_STMT *stmt)
{
  MYSQL *mysql= stmt->mysql;
  MYSQL_RES *result;
5240
  DBUG_ENTER("mysql_stmt_store_result");
5241 5242 5243 5244 5245 5246 5247

  mysql= mysql->last_used_con;

  if (!stmt->field_count)
    DBUG_RETURN(0);
  if (mysql->status != MYSQL_STATUS_GET_RESULT)
  {
5248 5249
    set_stmt_error(stmt, CR_COMMANDS_OUT_OF_SYNC);
    DBUG_RETURN(1);
5250 5251 5252 5253 5254 5255 5256
  }
  mysql->status= MYSQL_STATUS_READY;		/* server is ready */
  if (!(result= (MYSQL_RES*) my_malloc((uint) (sizeof(MYSQL_RES)+
					      sizeof(ulong) *
					      stmt->field_count),
				      MYF(MY_WME | MY_ZEROFILL))))
  {
5257
    set_stmt_error(stmt, CR_OUT_OF_MEMORY);
5258
    DBUG_RETURN(1);
5259
  }
5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271
  stmt->result_buffered= 1;
  if (!(result->data= read_binary_rows(stmt)))
  {
    my_free((gptr) result,MYF(0));
    DBUG_RETURN(0);
  }
  mysql->affected_rows= result->row_count= result->data->rows;
  result->data_cursor=	result->data->data;
  result->fields=	stmt->fields;
  result->field_count=	stmt->field_count;
  stmt->result= result;
  DBUG_RETURN(0); /* Data buffered, must be fetched with mysql_fetch() */
5272 5273 5274 5275 5276 5277
}


/********************************************************************
 Misc function implementations
*********************************************************************/
5278

5279
/*
unknown's avatar
unknown committed
5280
  Close the statement handle by freeing all alloced resources
5281

unknown's avatar
unknown committed
5282 5283 5284 5285 5286 5287 5288 5289 5290
  SYNOPSIS
    mysql_stmt_close()
    stmt	       Statement handle
    skip_list    Flag to indicate delete from list or not
  RETURN VALUES
    0	ok
    1	error
*/
static my_bool stmt_close(MYSQL_STMT *stmt, my_bool skip_list)
5291
{
5292
  my_bool error= 0;
5293 5294
  DBUG_ENTER("mysql_stmt_close");

unknown's avatar
unknown committed
5295 5296
  DBUG_ASSERT(stmt != 0);
  if (stmt->state == MY_ST_PREPARE || stmt->state == MY_ST_EXECUTE)
5297 5298 5299
  {
    char buff[4];
    int4store(buff, stmt->stmt_id);
unknown's avatar
unknown committed
5300
    error= simple_command(stmt->mysql, COM_CLOSE_STMT, buff, 4, 1);
5301
  }
5302 5303 5304 5305 5306
  mysql_free_result(stmt->result);
  free_root(&stmt->mem_root, MYF(0));
  if (!skip_list)
    stmt->mysql->stmts= list_delete(stmt->mysql->stmts, &stmt->list);
  my_free((gptr) stmt, MYF(MY_WME));
5307
  DBUG_RETURN(error);
5308 5309
}

unknown's avatar
unknown committed
5310 5311 5312 5313 5314
my_bool STDCALL mysql_stmt_close(MYSQL_STMT *stmt)
{
  return stmt_close(stmt, 0);
}

5315 5316 5317 5318 5319 5320 5321
/*
  Return statement error code
*/

uint STDCALL mysql_stmt_errno(MYSQL_STMT * stmt)
{
  DBUG_ENTER("mysql_stmt_errno");
5322
  DBUG_RETURN(stmt->last_errno);
5323 5324 5325 5326 5327 5328 5329 5330 5331
}

/*
  Return statement error message
*/

const char *STDCALL mysql_stmt_error(MYSQL_STMT * stmt)
{
  DBUG_ENTER("mysql_stmt_error");
5332
  DBUG_RETURN(stmt->last_error);
5333 5334 5335 5336 5337 5338
}

/*
  Commit the current transaction
*/

5339
my_bool STDCALL mysql_commit(MYSQL * mysql)
5340 5341
{
  DBUG_ENTER("mysql_commit");
5342
  DBUG_RETURN((my_bool) mysql_real_query(mysql, "commit", 6));
5343 5344 5345
}

/*
5346
  Rollback the current transaction
5347 5348
*/

5349
my_bool STDCALL mysql_rollback(MYSQL * mysql)
5350 5351
{
  DBUG_ENTER("mysql_rollback");
5352
  DBUG_RETURN((my_bool) mysql_real_query(mysql, "rollback", 8));
5353 5354 5355 5356 5357 5358 5359
}


/*
  Set autocommit to either true or false
*/

5360
my_bool STDCALL mysql_autocommit(MYSQL * mysql, my_bool auto_mode)
5361 5362 5363 5364 5365
{
  DBUG_ENTER("mysql_autocommit");
  DBUG_PRINT("enter", ("mode : %d", auto_mode));

  if (auto_mode) /* set to true */
5366 5367
    DBUG_RETURN((my_bool) mysql_real_query(mysql, "set autocommit=1", 16));
  DBUG_RETURN((my_bool) mysql_real_query(mysql, "set autocommit=0", 16));
5368
}
5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401


/********************************************************************
 Multi query execution related implementations
*********************************************************************/

/*
  Returns if there are any more query results exists to be read using 
  mysql_next_result()
*/

my_bool STDCALL mysql_more_results(MYSQL *mysql)
{
  if (mysql->last_used_con->server_status & SERVER_MORE_RESULTS_EXISTS)
    return 1;
  return 0;
}

/*
  Reads and returns the next query results
*/

my_bool STDCALL mysql_next_result(MYSQL *mysql)
{
  
  mysql->net.last_error[0]=0;
  mysql->net.last_errno=0;
  mysql->affected_rows= ~(my_ulonglong) 0;

  if (mysql->last_used_con->server_status & SERVER_MORE_RESULTS_EXISTS)
    return mysql_read_query_result(mysql);
  return 0;
}