← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/client.c

Cleanup around SAFEMALLOC

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/client.c
 
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 MySQL
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; either version 2 of the License, or
 
9
 *  (at your option) any later version.
 
10
 *
 
11
 *  This program is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *  GNU General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU General Public License
 
17
 *  along with this program; if not, write to the Free Software
 
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
19
 */
 
20
 
 
21
 
 
22
/*
 
23
  This file is included by both libdrizzle.c (the DRIZZLE client C API)
 
24
  and the drizzled server to connect to another DRIZZLE server.
 
25
 
 
26
  The differences for the two cases are:
 
27
 
 
28
  - Things that only works for the client:
 
29
  - Trying to automaticly determinate user name if not supplied to
 
30
    drizzle_connect()
 
31
  - Support for reading local file with LOAD DATA LOCAL
 
32
  - SHARED memory handling
 
33
  - Protection against sigpipe
 
34
  - Prepared statements
 
35
 
 
36
  - Things that only works for the server
 
37
  - Alarm handling on connect
 
38
 
 
39
  In all other cases, the code should be idential for the client and
 
40
  server.
 
41
*/
 
42
 
 
43
#include <drizzled/global.h>
 
44
 
 
45
#include "drizzle.h"
 
46
 
 
47
#include <sys/poll.h>
 
48
#include <sys/ioctl.h>
 
49
 
 
50
#include <netdb.h>
 
51
 
 
52
/* Remove client convenience wrappers */
 
53
#undef max_allowed_packet
 
54
#undef net_buffer_length
 
55
 
 
56
#define CLI_DRIZZLE_CONNECT drizzle_connect
 
57
 
 
58
#include <mysys/my_sys.h>
 
59
#include <mystrings/m_string.h>
 
60
#include <mystrings/m_ctype.h>
 
61
#include <drizzled/error.h>
 
62
#include "errmsg.h"
 
63
#include <vio/violite.h>
 
64
 
 
65
#include <sys/stat.h>
 
66
#include <signal.h>
 
67
#include <time.h>
 
68
#ifdef   HAVE_PWD_H
 
69
#include <pwd.h>
 
70
#endif
 
71
 
 
72
#include <sys/socket.h>
 
73
#include <netinet/in.h>
 
74
#include <arpa/inet.h>
 
75
#include <netdb.h>
 
76
#ifdef HAVE_SELECT_H
 
77
#  include <select.h>
 
78
#endif
 
79
#ifdef HAVE_SYS_SELECT_H
 
80
#include <sys/select.h>
 
81
#endif
 
82
 
 
83
#include <sys/un.h>
 
84
 
 
85
#include <errno.h>
 
86
#define SOCKET_ERROR -1
 
87
 
 
88
#define CONNECT_TIMEOUT 0
 
89
 
 
90
#include "client_settings.h"
 
91
#include <drizzled/version.h>
 
92
#include <libdrizzle/sql_common.h>
 
93
#include <libdrizzle/gettext.h>
 
94
 
 
95
uint    drizzle_port=0;
 
96
char    *drizzle_unix_port= 0;
 
97
const char  *unknown_sqlstate= "HY000";
 
98
const char  *not_error_sqlstate= "00000";
 
99
const char  *cant_connect_sqlstate= "08001";
 
100
 
 
101
static bool drizzle_client_init= false;
 
102
static bool org_my_init_done= false;
 
103
 
 
104
static void drizzle_close_free_options(DRIZZLE *drizzle);
 
105
static void drizzle_close_free(DRIZZLE *drizzle);
 
106
 
 
107
static int wait_for_data(int fd, int32_t timeout);
 
108
int connect_with_timeout(int fd, const struct sockaddr *name, uint namelen, int32_t timeout);
 
109
 
 
110
CHARSET_INFO *default_client_charset_info = &my_charset_utf8_general_ci;
 
111
 
 
112
/* Server error code and message */
 
113
unsigned int drizzle_server_last_errno;
 
114
char drizzle_server_last_error[DRIZZLE_ERRMSG_SIZE];
 
115
 
 
116
/****************************************************************************
 
117
  A modified version of connect().  connect_with_timeout() allows you to specify
 
118
  a timeout value, in seconds, that we should wait until we
 
119
  derermine we can't connect to a particular host.  If timeout is 0,
 
120
  connect_with_timeout() will behave exactly like connect().
 
121
 
 
122
  Base version coded by Steve Bernacki, Jr. <steve@navinet.net>
 
123
*****************************************************************************/
 
124
 
 
125
 
 
126
int connect_with_timeout(int fd, const struct sockaddr *name, uint namelen, int32_t timeout)
 
127
{
 
128
  int flags, res, s_err;
 
129
 
 
130
  /*
 
131
    If they passed us a timeout of zero, we should behave
 
132
    exactly like the normal connect() call does.
 
133
  */
 
134
 
 
135
  if (timeout == 0)
 
136
    return connect(fd, (struct sockaddr*) name, namelen);
 
137
 
 
138
  flags = fcntl(fd, F_GETFL, 0);    /* Set socket to not block */
 
139
#ifdef O_NONBLOCK
 
140
  fcntl(fd, F_SETFL, flags | O_NONBLOCK);  /* and save the flags..  */
 
141
#endif
 
142
 
 
143
  res= connect(fd, (struct sockaddr*) name, namelen);
 
144
  s_err= errno;      /* Save the error... */
 
145
  fcntl(fd, F_SETFL, flags);
 
146
  if ((res != 0) && (s_err != EINPROGRESS))
 
147
  {
 
148
    errno= s_err;      /* Restore it */
 
149
    return(-1);
 
150
  }
 
151
  if (res == 0)        /* Connected quickly! */
 
152
    return(0);
 
153
 
 
154
  return wait_for_data(fd, timeout);
 
155
}
 
156
 
 
157
 
 
158
/*
 
159
  Wait up to timeout seconds for a connection to be established.
 
160
 
 
161
  We prefer to do this with poll() as there is no limitations with this.
 
162
  If not, we will use select()
 
163
*/
 
164
 
 
165
static int wait_for_data(int fd, int32_t timeout)
 
166
{
 
167
  struct pollfd ufds;
 
168
  int res;
 
169
 
 
170
  ufds.fd= fd;
 
171
  ufds.events= POLLIN | POLLPRI;
 
172
  if (!(res= poll(&ufds, 1, (int) timeout*1000)))
 
173
  {
 
174
    errno= EINTR;
 
175
    return -1;
 
176
  }
 
177
  if (res < 0 || !(ufds.revents & (POLLIN | POLLPRI)) || (ufds.revents & POLLHUP))
 
178
    return -1;
 
179
  return 0;
 
180
}
 
181
 
 
182
 
 
183
#if defined(HAVE_GETPWUID) && defined(NO_GETPWUID_DECL)
 
184
struct passwd *getpwuid(uid_t);
 
185
char* getlogin(void);
 
186
#endif
 
187
 
 
188
static void read_user_name(char *name)
 
189
{
 
190
  if (geteuid() == 0)
 
191
    strcpy(name,"root");    /* allow use of surun */
 
192
  else
 
193
  {
 
194
#ifdef HAVE_GETPWUID
 
195
    struct passwd *skr;
 
196
    const char *str;
 
197
    if ((str=getlogin()) == NULL)
 
198
    {
 
199
      if ((skr=getpwuid(geteuid())) != NULL)
 
200
  str=skr->pw_name;
 
201
      else if (!(str=getenv("USER")) && !(str=getenv("LOGNAME")) &&
 
202
         !(str=getenv("LOGIN")))
 
203
  str="UNKNOWN_USER";
 
204
    }
 
205
    strncpy(name,str,USERNAME_LENGTH);
 
206
#elif HAVE_CUSERID
 
207
    (void) cuserid(name);
 
208
#else
 
209
    strcpy(name,"UNKNOWN_USER");
 
210
#endif
 
211
  }
 
212
  return;
 
213
}
 
214
 
 
215
 
 
216
/**
 
217
  Set the internal error message to DRIZZLE handler
 
218
 
 
219
  @param drizzle connection handle (client side)
 
220
  @param errcode  CR_ error code, passed to ER macro to get
 
221
                  error text
 
222
  @parma sqlstate SQL standard sqlstate
 
223
*/
 
224
 
 
225
void set_drizzle_error(DRIZZLE *drizzle, int errcode, const char *sqlstate)
 
226
{
 
227
  NET *net;
 
228
  assert(drizzle != 0);
 
229
 
 
230
  if (drizzle)
 
231
  {
 
232
    net= &drizzle->net;
 
233
    net->last_errno= errcode;
 
234
    strcpy(net->last_error, ER(errcode));
 
235
    strcpy(net->sqlstate, sqlstate);
 
236
  }
 
237
  else
 
238
  {
 
239
    drizzle_server_last_errno= errcode;
 
240
    strcpy(drizzle_server_last_error, ER(errcode));
 
241
  }
 
242
  return;
 
243
}
 
244
 
 
245
/**
 
246
  Clear possible error state of struct NET
 
247
 
 
248
  @param net  clear the state of the argument
 
249
*/
 
250
 
 
251
void net_clear_error(NET *net)
 
252
{
 
253
  net->last_errno= 0;
 
254
  net->last_error[0]= '\0';
 
255
  strcpy(net->sqlstate, not_error_sqlstate);
 
256
}
 
257
 
 
258
/**
 
259
  Set an error message on the client.
 
260
 
 
261
  @param drizzle connection handle
 
262
  @param errcode   CR_* errcode, for client errors
 
263
  @param sqlstate  SQL standard sql state, unknown_sqlstate for the
 
264
                   majority of client errors.
 
265
  @param format    error message template, in sprintf format
 
266
  @param ...       variable number of arguments
 
267
*/
 
268
 
 
269
static void set_drizzle_extended_error(DRIZZLE *drizzle, int errcode,
 
270
                                     const char *sqlstate,
 
271
                                     const char *format, ...)
 
272
{
 
273
  NET *net;
 
274
  va_list args;
 
275
  assert(drizzle != 0);
 
276
 
 
277
  net= &drizzle->net;
 
278
  net->last_errno= errcode;
 
279
  va_start(args, format);
 
280
  vsnprintf(net->last_error, sizeof(net->last_error)-1,
 
281
               format, args);
 
282
  va_end(args);
 
283
  strcpy(net->sqlstate, sqlstate);
 
284
 
 
285
  return;
 
286
}
 
287
 
 
288
/*****************************************************************************
 
289
  Read a packet from server. Give error message if socket was down
 
290
  or packet is an error message
 
291
*****************************************************************************/
 
292
 
 
293
uint32_t cli_safe_read(DRIZZLE *drizzle)
 
294
{
 
295
  NET *net= &drizzle->net;
 
296
  uint32_t len=0;
 
297
  init_sigpipe_variables
 
298
 
 
299
  /* Don't give sigpipe errors if the client doesn't want them */
 
300
  set_sigpipe(drizzle);
 
301
  if (net->vio != 0)
 
302
    len=my_net_read(net);
 
303
  reset_sigpipe(drizzle);
 
304
 
 
305
  if (len == packet_error || len == 0)
 
306
  {
 
307
#ifdef DRIZZLE_SERVER
 
308
    if (net->vio && vio_was_interrupted(net->vio))
 
309
      return (packet_error);
 
310
#endif /*DRIZZLE_SERVER*/
 
311
    end_server(drizzle);
 
312
    set_drizzle_error(drizzle, net->last_errno == ER_NET_PACKET_TOO_LARGE ?
 
313
                    CR_NET_PACKET_TOO_LARGE: CR_SERVER_LOST, unknown_sqlstate);
 
314
    return (packet_error);
 
315
  }
 
316
  if (net->read_pos[0] == 255)
 
317
  {
 
318
    if (len > 3)
 
319
    {
 
320
      char *pos=(char*) net->read_pos+1;
 
321
      net->last_errno=uint2korr(pos);
 
322
      pos+=2;
 
323
      len-=2;
 
324
      if (pos[0] == '#')
 
325
      {
 
326
        strncpy(net->sqlstate, pos+1, SQLSTATE_LENGTH);
 
327
        pos+= SQLSTATE_LENGTH+1;
 
328
      }
 
329
      else
 
330
      {
 
331
        /*
 
332
          The SQL state hasn't been received -- it should be reset to HY000
 
333
          (unknown error sql state).
 
334
        */
 
335
 
 
336
        strcpy(net->sqlstate, unknown_sqlstate);
 
337
      }
 
338
 
 
339
      strncpy(net->last_error,(char*) pos, min((uint) len,
 
340
              (uint32_t) sizeof(net->last_error)-1));
 
341
    }
 
342
    else
 
343
      set_drizzle_error(drizzle, CR_UNKNOWN_ERROR, unknown_sqlstate);
 
344
    /*
 
345
      Cover a protocol design error: error packet does not
 
346
      contain the server status. Therefore, the client has no way
 
347
      to find out whether there are more result sets of
 
348
      a multiple-result-set statement pending. Luckily, in 5.0 an
 
349
      error always aborts execution of a statement, wherever it is
 
350
      a multi-statement or a stored procedure, so it should be
 
351
      safe to unconditionally turn off the flag here.
 
352
    */
 
353
    drizzle->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
 
354
 
 
355
    return(packet_error);
 
356
  }
 
357
  return len;
 
358
}
 
359
 
 
360
void free_rows(DRIZZLE_DATA *cur)
 
361
{
 
362
  if (cur)
 
363
  {
 
364
    free_root(&cur->alloc,MYF(0));
 
365
    my_free((uchar*) cur,MYF(0));
 
366
  }
 
367
}
 
368
 
 
369
bool
 
370
cli_advanced_command(DRIZZLE *drizzle, enum enum_server_command command,
 
371
         const unsigned char *header, uint32_t header_length,
 
372
         const unsigned char *arg, uint32_t arg_length, bool skip_check)
 
373
{
 
374
  NET *net= &drizzle->net;
 
375
  bool result= 1;
 
376
  init_sigpipe_variables
 
377
  bool stmt_skip= false;
 
378
 
 
379
  /* Don't give sigpipe errors if the client doesn't want them */
 
380
  set_sigpipe(drizzle);
 
381
 
 
382
  if (drizzle->net.vio == 0)
 
383
  {            /* Do reconnect if possible */
 
384
    if (drizzle_reconnect(drizzle) || stmt_skip)
 
385
      return(1);
 
386
  }
 
387
  if (drizzle->status != DRIZZLE_STATUS_READY ||
 
388
      drizzle->server_status & SERVER_MORE_RESULTS_EXISTS)
 
389
  {
 
390
    set_drizzle_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
 
391
    return(1);
 
392
  }
 
393
 
 
394
  net_clear_error(net);
 
395
  drizzle->info=0;
 
396
  drizzle->affected_rows= ~(uint64_t) 0;
 
397
  /*
 
398
    We don't want to clear the protocol buffer on COM_QUIT, because if
 
399
    the previous command was a shutdown command, we may have the
 
400
    response for the COM_QUIT already in the communication buffer
 
401
  */
 
402
  net_clear(&drizzle->net, (command != COM_QUIT));
 
403
 
 
404
  if (net_write_command(net,(uchar) command, header, header_length,
 
405
      arg, arg_length))
 
406
  {
 
407
    if (net->last_errno == ER_NET_PACKET_TOO_LARGE)
 
408
    {
 
409
      set_drizzle_error(drizzle, CR_NET_PACKET_TOO_LARGE, unknown_sqlstate);
 
410
      goto end;
 
411
    }
 
412
    end_server(drizzle);
 
413
    if (drizzle_reconnect(drizzle) || stmt_skip)
 
414
      goto end;
 
415
    if (net_write_command(net,(uchar) command, header, header_length,
 
416
        arg, arg_length))
 
417
    {
 
418
      set_drizzle_error(drizzle, CR_SERVER_GONE_ERROR, unknown_sqlstate);
 
419
      goto end;
 
420
    }
 
421
  }
 
422
  result=0;
 
423
  if (!skip_check)
 
424
    result= ((drizzle->packet_length=cli_safe_read(drizzle)) == packet_error ?
 
425
       1 : 0);
 
426
end:
 
427
  reset_sigpipe(drizzle);
 
428
  return(result);
 
429
}
 
430
 
 
431
void free_old_query(DRIZZLE *drizzle)
 
432
{
 
433
  if (drizzle->fields)
 
434
    free_root(&drizzle->field_alloc,MYF(0));
 
435
  init_alloc_root(&drizzle->field_alloc,8192,0); /* Assume rowlength < 8192 */
 
436
  drizzle->fields= 0;
 
437
  drizzle->field_count= 0;      /* For API */
 
438
  drizzle->warning_count= 0;
 
439
  drizzle->info= 0;
 
440
  return;
 
441
}
 
442
 
 
443
/*
 
444
  Flush result set sent from server
 
445
*/
 
446
 
 
447
static void cli_flush_use_result(DRIZZLE *drizzle)
 
448
{
 
449
  /* Clear the current execution status */
 
450
  for (;;)
 
451
  {
 
452
    uint32_t pkt_len;
 
453
    if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
 
454
      break;
 
455
    if (pkt_len <= 8 && drizzle->net.read_pos[0] == DRIZZLE_PROTOCOL_NO_MORE_DATA)
 
456
    {
 
457
      char *pos= (char*) drizzle->net.read_pos + 1;
 
458
      drizzle->warning_count=uint2korr(pos); pos+=2;
 
459
      drizzle->server_status=uint2korr(pos); pos+=2;
 
460
 
 
461
      break;                            /* End of data */
 
462
    }
 
463
  }
 
464
  return;
 
465
}
 
466
 
 
467
 
 
468
/**************************************************************************
 
469
  Shut down connection
 
470
**************************************************************************/
 
471
 
 
472
void end_server(DRIZZLE *drizzle)
 
473
{
 
474
  int save_errno= errno;
 
475
  if (drizzle->net.vio != 0)
 
476
  {
 
477
    init_sigpipe_variables
 
478
    set_sigpipe(drizzle);
 
479
    vio_delete(drizzle->net.vio);
 
480
    reset_sigpipe(drizzle);
 
481
    drizzle->net.vio= 0;          /* Marker */
 
482
  }
 
483
  net_end(&drizzle->net);
 
484
  free_old_query(drizzle);
 
485
  errno= save_errno;
 
486
}
 
487
 
 
488
 
 
489
void
 
490
drizzle_free_result(DRIZZLE_RES *result)
 
491
{
 
492
  if (result)
 
493
  {
 
494
    DRIZZLE *drizzle= result->handle;
 
495
    if (drizzle)
 
496
    {
 
497
      if (drizzle->unbuffered_fetch_owner == &result->unbuffered_fetch_cancelled)
 
498
        drizzle->unbuffered_fetch_owner= 0;
 
499
      if (drizzle->status == DRIZZLE_STATUS_USE_RESULT)
 
500
      {
 
501
        (*drizzle->methods->flush_use_result)(drizzle);
 
502
        drizzle->status=DRIZZLE_STATUS_READY;
 
503
        if (drizzle->unbuffered_fetch_owner)
 
504
          *drizzle->unbuffered_fetch_owner= true;
 
505
      }
 
506
    }
 
507
    free_rows(result->data);
 
508
    if (result->fields)
 
509
      free_root(&result->field_alloc,MYF(0));
 
510
    if (result->row)
 
511
      my_free((uchar*) result->row,MYF(0));
 
512
    my_free((uchar*) result,MYF(0));
 
513
  }
 
514
}
 
515
 
 
516
/****************************************************************************
 
517
  Get options from my.cnf
 
518
****************************************************************************/
 
519
 
 
520
static const char *default_options[]=
 
521
{
 
522
  "port","socket","compress","password","pipe", "timeout", "user",
 
523
  "init-command", "host", "database", "return-found-rows",
 
524
  "ssl-key" ,"ssl-cert" ,"ssl-ca" ,"ssl-capath",
 
525
  "character-sets-dir", "default-character-set", "interactive-timeout",
 
526
  "connect-timeout", "local-infile", "disable-local-infile",
 
527
  "ssl-cipher", "max-allowed-packet", "protocol", "shared-memory-base-name",
 
528
  "multi-results", "multi-statements", "multi-queries", "secure-auth",
 
529
  "report-data-truncation",
 
530
  NullS
 
531
};
 
532
 
 
533
static TYPELIB option_types={array_elements(default_options)-1,
 
534
           "options",default_options, NULL};
 
535
 
 
536
const char *sql_protocol_names_lib[] =
 
537
{ "TCP", "SOCKET", "PIPE", "MEMORY", NullS };
 
538
TYPELIB sql_protocol_typelib = {array_elements(sql_protocol_names_lib)-1,"",
 
539
        sql_protocol_names_lib, NULL};
 
540
 
 
541
static int add_init_command(struct st_drizzle_options *options, const char *cmd)
 
542
{
 
543
  char *tmp;
 
544
 
 
545
  if (!options->init_commands)
 
546
  {
 
547
    options->init_commands= (DYNAMIC_ARRAY*)my_malloc(sizeof(DYNAMIC_ARRAY),
 
548
                  MYF(MY_WME));
 
549
    init_dynamic_array(options->init_commands,sizeof(char*),0,5 CALLER_INFO);
 
550
  }
 
551
 
 
552
  if (!(tmp= my_strdup(cmd,MYF(MY_WME))) ||
 
553
      insert_dynamic(options->init_commands, (uchar*)&tmp))
 
554
  {
 
555
    my_free(tmp, MYF(MY_ALLOW_ZERO_PTR));
 
556
    return 1;
 
557
  }
 
558
 
 
559
  return 0;
 
560
}
 
561
 
 
562
void drizzle_read_default_options(struct st_drizzle_options *options,
 
563
        const char *filename,const char *group)
 
564
{
 
565
  int argc;
 
566
  char *argv_buff[1],**argv;
 
567
  const char *groups[3];
 
568
 
 
569
  argc=1; argv=argv_buff; argv_buff[0]= (char*) "client";
 
570
  groups[0]= (char*) "client"; groups[1]= (char*) group; groups[2]=0;
 
571
 
 
572
  load_defaults(filename, groups, &argc, &argv);
 
573
  if (argc != 1)        /* If some default option */
 
574
  {
 
575
    char **option=argv;
 
576
    while (*++option)
 
577
    {
 
578
      if (option[0][0] == '-' && option[0][1] == '-')
 
579
      {
 
580
        char *end=strrchr(*option,'=');
 
581
        char *opt_arg=0;
 
582
        if (end != NULL)
 
583
        {
 
584
          opt_arg=end+1;
 
585
          *end=0;        /* Remove '=' */
 
586
        }
 
587
        /* Change all '_' in variable name to '-' */
 
588
        for (end= *option ; *(end= strrchr(end,'_')) ; )
 
589
          *end= '-';
 
590
        switch (find_type(*option+2,&option_types,2)) {
 
591
        case 1:        /* port */
 
592
          if (opt_arg)
 
593
            options->port=atoi(opt_arg);
 
594
          break;
 
595
        case 2:        /* socket */
 
596
          if (opt_arg)
 
597
          {
 
598
            my_free(options->unix_socket,MYF(MY_ALLOW_ZERO_PTR));
 
599
            options->unix_socket=my_strdup(opt_arg,MYF(MY_WME));
 
600
          }
 
601
          break;
 
602
        case 3:        /* compress */
 
603
          options->compress=1;
 
604
          options->client_flag|= CLIENT_COMPRESS;
 
605
          break;
 
606
        case 4:        /* password */
 
607
          if (opt_arg)
 
608
          {
 
609
            my_free(options->password,MYF(MY_ALLOW_ZERO_PTR));
 
610
            options->password=my_strdup(opt_arg,MYF(MY_WME));
 
611
          }
 
612
          break;
 
613
        case 20:      /* connect_timeout */
 
614
        case 6:        /* timeout */
 
615
          if (opt_arg)
 
616
            options->connect_timeout=atoi(opt_arg);
 
617
          break;
 
618
        case 7:        /* user */
 
619
          if (opt_arg)
 
620
          {
 
621
            my_free(options->user,MYF(MY_ALLOW_ZERO_PTR));
 
622
            options->user=my_strdup(opt_arg,MYF(MY_WME));
 
623
          }
 
624
          break;
 
625
        case 8:        /* init-command */
 
626
          add_init_command(options,opt_arg);
 
627
          break;
 
628
        case 9:        /* host */
 
629
          if (opt_arg)
 
630
          {
 
631
            my_free(options->host,MYF(MY_ALLOW_ZERO_PTR));
 
632
            options->host=my_strdup(opt_arg,MYF(MY_WME));
 
633
          }
 
634
          break;
 
635
        case 10:      /* database */
 
636
          if (opt_arg)
 
637
          {
 
638
            my_free(options->db,MYF(MY_ALLOW_ZERO_PTR));
 
639
            options->db=my_strdup(opt_arg,MYF(MY_WME));
 
640
          }
 
641
          break;
 
642
        case 12:      /* return-found-rows */
 
643
          options->client_flag|=CLIENT_FOUND_ROWS;
 
644
          break;
 
645
        case 13:        /* Ignore SSL options */
 
646
        case 14:
 
647
        case 15:
 
648
        case 16:
 
649
        case 23:
 
650
          break;
 
651
        case 17:      /* charset-lib */
 
652
          my_free(options->charset_dir,MYF(MY_ALLOW_ZERO_PTR));
 
653
          options->charset_dir = my_strdup(opt_arg, MYF(MY_WME));
 
654
          break;
 
655
        case 18:
 
656
          my_free(options->charset_name,MYF(MY_ALLOW_ZERO_PTR));
 
657
          options->charset_name = my_strdup(opt_arg, MYF(MY_WME));
 
658
          break;
 
659
        case 19:        /* Interactive-timeout */
 
660
          options->client_flag|= CLIENT_INTERACTIVE;
 
661
          break;
 
662
        case 21:
 
663
          if (!opt_arg || atoi(opt_arg) != 0)
 
664
            options->client_flag|= CLIENT_LOCAL_FILES;
 
665
          else
 
666
            options->client_flag&= ~CLIENT_LOCAL_FILES;
 
667
          break;
 
668
        case 22:
 
669
          options->client_flag&= ~CLIENT_LOCAL_FILES;
 
670
          break;
 
671
        case 24: /* max-allowed-packet */
 
672
          if (opt_arg)
 
673
            options->max_allowed_packet= atoi(opt_arg);
 
674
          break;
 
675
        case 25: /* protocol */
 
676
          if ((options->protocol= find_type(opt_arg,
 
677
                                            &sql_protocol_typelib,0)) <= 0)
 
678
          {
 
679
            fprintf(stderr, _("Unknown option to protocol: %s\n"), opt_arg);
 
680
            exit(1);
 
681
          }
 
682
          break;
 
683
        case 27: /* multi-results */
 
684
          options->client_flag|= CLIENT_MULTI_RESULTS;
 
685
          break;
 
686
        case 28: /* multi-statements */
 
687
        case 29: /* multi-queries */
 
688
          options->client_flag|= CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS;
 
689
          break;
 
690
        case 30: /* secure-auth */
 
691
          options->secure_auth= true;
 
692
          break;
 
693
        case 31: /* report-data-truncation */
 
694
          options->report_data_truncation= opt_arg ? test(atoi(opt_arg)) : 1;
 
695
          break;
 
696
        default:
 
697
          break;
 
698
        }
 
699
      }
 
700
    }
 
701
  }
 
702
  free_defaults(argv);
 
703
  return;
 
704
}
 
705
 
 
706
 
 
707
/**************************************************************************
 
708
  Get column lengths of the current row
 
709
  If one uses drizzle_use_result, res->lengths contains the length information,
 
710
  else the lengths are calculated from the offset between pointers.
 
711
**************************************************************************/
 
712
 
 
713
static void cli_fetch_lengths(uint32_t *to, DRIZZLE_ROW column, uint32_t field_count)
 
714
{
 
715
  uint32_t *prev_length;
 
716
  char *start=0;
 
717
  DRIZZLE_ROW end;
 
718
 
 
719
  prev_length=0;        /* Keep gcc happy */
 
720
  for (end=column + field_count + 1 ; column != end ; column++, to++)
 
721
  {
 
722
    if (!*column)
 
723
    {
 
724
      *to= 0;          /* Null */
 
725
      continue;
 
726
    }
 
727
    if (start)          /* Found end of prev string */
 
728
      *prev_length= (uint32_t) (*column-start-1);
 
729
    start= *column;
 
730
    prev_length= to;
 
731
  }
 
732
}
 
733
 
 
734
/***************************************************************************
 
735
  Change field rows to field structs
 
736
***************************************************************************/
 
737
 
 
738
DRIZZLE_FIELD *
 
739
unpack_fields(DRIZZLE_DATA *data, MEM_ROOT *alloc,uint fields,
 
740
              bool default_value)
 
741
{
 
742
  DRIZZLE_ROWS  *row;
 
743
  DRIZZLE_FIELD  *field,*result;
 
744
  uint32_t lengths[9];        /* Max of fields */
 
745
 
 
746
  field= result= (DRIZZLE_FIELD*) alloc_root(alloc,
 
747
             (uint) sizeof(*field)*fields);
 
748
  if (!result)
 
749
  {
 
750
    free_rows(data);        /* Free old data */
 
751
    return(0);
 
752
  }
 
753
  memset((char*) field, 0, (uint) sizeof(DRIZZLE_FIELD)*fields);
 
754
 
 
755
  for (row= data->data; row ; row = row->next,field++)
 
756
  {
 
757
    uchar *pos;
 
758
    /* fields count may be wrong */
 
759
    assert((uint) (field - result) < fields);
 
760
    cli_fetch_lengths(&lengths[0], row->data, default_value ? 8 : 7);
 
761
    field->catalog=   strmake_root(alloc,(char*) row->data[0], lengths[0]);
 
762
    field->db=        strmake_root(alloc,(char*) row->data[1], lengths[1]);
 
763
    field->table=     strmake_root(alloc,(char*) row->data[2], lengths[2]);
 
764
    field->org_table= strmake_root(alloc,(char*) row->data[3], lengths[3]);
 
765
    field->name=      strmake_root(alloc,(char*) row->data[4], lengths[4]);
 
766
    field->org_name=  strmake_root(alloc,(char*) row->data[5], lengths[5]);
 
767
 
 
768
    field->catalog_length=  lengths[0];
 
769
    field->db_length=    lengths[1];
 
770
    field->table_length=  lengths[2];
 
771
    field->org_table_length=  lengths[3];
 
772
    field->name_length=  lengths[4];
 
773
    field->org_name_length=  lengths[5];
 
774
 
 
775
    /* Unpack fixed length parts */
 
776
    pos= (uchar*) row->data[6];
 
777
    field->charsetnr= uint2korr(pos);
 
778
    field->length=  (uint) uint4korr(pos+2);
 
779
    field->type=  (enum enum_field_types) pos[6];
 
780
    field->flags=  uint2korr(pos+7);
 
781
    field->decimals=  (uint) pos[9];
 
782
 
 
783
    if (INTERNAL_NUM_FIELD(field))
 
784
      field->flags|= NUM_FLAG;
 
785
    if (default_value && row->data[7])
 
786
    {
 
787
      field->def=strmake_root(alloc,(char*) row->data[7], lengths[7]);
 
788
      field->def_length= lengths[7];
 
789
    }
 
790
    else
 
791
      field->def=0;
 
792
    field->max_length= 0;
 
793
  }
 
794
 
 
795
  free_rows(data);        /* Free old data */
 
796
  return(result);
 
797
}
 
798
 
 
799
/* Read all rows (fields or data) from server */
 
800
 
 
801
DRIZZLE_DATA *cli_read_rows(DRIZZLE *drizzle, DRIZZLE_FIELD *DRIZZLE_FIELDs, uint32_t fields)
 
802
{
 
803
  uint32_t  field;
 
804
  uint32_t pkt_len;
 
805
  uint32_t len;
 
806
  unsigned char *cp;
 
807
  char  *to, *end_to;
 
808
  DRIZZLE_DATA *result;
 
809
  DRIZZLE_ROWS **prev_ptr,*cur;
 
810
  NET *net = &drizzle->net;
 
811
 
 
812
  if ((pkt_len= cli_safe_read(drizzle)) == packet_error)
 
813
    return(0);
 
814
  if (!(result=(DRIZZLE_DATA*) my_malloc(sizeof(DRIZZLE_DATA),
 
815
               MYF(MY_WME | MY_ZEROFILL))))
 
816
  {
 
817
    set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
 
818
    return(0);
 
819
  }
 
820
  init_alloc_root(&result->alloc,8192,0);  /* Assume rowlength < 8192 */
 
821
  result->alloc.min_malloc=sizeof(DRIZZLE_ROWS);
 
822
  prev_ptr= &result->data;
 
823
  result->rows=0;
 
824
  result->fields=fields;
 
825
 
 
826
  /*
 
827
    The last EOF packet is either a 254 (0xFE) character followed by 1-7 status bytes.
 
828
 
 
829
    This doesn't conflict with normal usage of 254 which stands for a
 
830
    string where the length of the string is 8 bytes. (see net_field_length())
 
831
  */
 
832
 
 
833
  while (*(cp=net->read_pos) != DRIZZLE_PROTOCOL_NO_MORE_DATA || pkt_len >= 8)
 
834
  {
 
835
    result->rows++;
 
836
    if (!(cur= (DRIZZLE_ROWS*) alloc_root(&result->alloc,
 
837
          sizeof(DRIZZLE_ROWS))) ||
 
838
  !(cur->data= ((DRIZZLE_ROW)
 
839
          alloc_root(&result->alloc,
 
840
         (fields+1)*sizeof(char *)+pkt_len))))
 
841
    {
 
842
      free_rows(result);
 
843
      set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
 
844
      return(0);
 
845
    }
 
846
    *prev_ptr=cur;
 
847
    prev_ptr= &cur->next;
 
848
    to= (char*) (cur->data+fields+1);
 
849
    end_to=to+pkt_len-1;
 
850
    for (field=0 ; field < fields ; field++)
 
851
    {
 
852
      if ((len= net_field_length(&cp)) == NULL_LENGTH)
 
853
      {            /* null field */
 
854
        cur->data[field] = 0;
 
855
      }
 
856
      else
 
857
      {
 
858
        cur->data[field] = to;
 
859
        if (len > (uint32_t) (end_to - to))
 
860
        {
 
861
          free_rows(result);
 
862
          set_drizzle_error(drizzle, CR_MALFORMED_PACKET, unknown_sqlstate);
 
863
          return(0);
 
864
        }
 
865
        memcpy(to, cp, len);
 
866
        to[len]=0;
 
867
        to+=len+1;
 
868
        cp+=len;
 
869
        if (DRIZZLE_FIELDs)
 
870
        {
 
871
          if (DRIZZLE_FIELDs[field].max_length < len)
 
872
            DRIZZLE_FIELDs[field].max_length=len;
 
873
        }
 
874
      }
 
875
    }
 
876
    cur->data[field]=to;      /* End of last field */
 
877
    if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
 
878
    {
 
879
      free_rows(result);
 
880
      return(0);
 
881
    }
 
882
  }
 
883
  *prev_ptr=0;          /* last pointer is null */
 
884
  if (pkt_len > 1)        /* DRIZZLE 4.1 protocol */
 
885
  {
 
886
    drizzle->warning_count= uint2korr(cp+1);
 
887
    drizzle->server_status= uint2korr(cp+3);
 
888
  }
 
889
  return(result);
 
890
}
 
891
 
 
892
/*
 
893
  Read one row. Uses packet buffer as storage for fields.
 
894
  When next packet is read, the previous field values are destroyed
 
895
*/
 
896
 
 
897
 
 
898
static int32_t
 
899
read_one_row(DRIZZLE *drizzle, uint32_t fields, DRIZZLE_ROW row, uint32_t *lengths)
 
900
{
 
901
  uint field;
 
902
  uint32_t pkt_len,len;
 
903
  uchar *pos, *prev_pos, *end_pos;
 
904
  NET *net= &drizzle->net;
 
905
 
 
906
  if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
 
907
    return -1;
 
908
  if (pkt_len <= 8 && net->read_pos[0] == DRIZZLE_PROTOCOL_NO_MORE_DATA)
 
909
  {
 
910
    if (pkt_len > 1)        /* DRIZZLE 4.1 protocol */
 
911
    {
 
912
      drizzle->warning_count= uint2korr(net->read_pos+1);
 
913
      drizzle->server_status= uint2korr(net->read_pos+3);
 
914
    }
 
915
    return 1;        /* End of data */
 
916
  }
 
917
  prev_pos= 0;        /* allowed to write at packet[-1] */
 
918
  pos=net->read_pos;
 
919
  end_pos=pos+pkt_len;
 
920
  for (field=0 ; field < fields ; field++)
 
921
  {
 
922
    if ((len= net_field_length(&pos)) == NULL_LENGTH)
 
923
    {            /* null field */
 
924
      row[field] = 0;
 
925
      *lengths++=0;
 
926
    }
 
927
    else
 
928
    {
 
929
      if (len > (uint32_t) (end_pos - pos))
 
930
      {
 
931
        set_drizzle_error(drizzle, CR_UNKNOWN_ERROR, unknown_sqlstate);
 
932
        return -1;
 
933
      }
 
934
      row[field] = (char*) pos;
 
935
      pos+=len;
 
936
      *lengths++=len;
 
937
    }
 
938
    if (prev_pos)
 
939
      *prev_pos=0;        /* Terminate prev field */
 
940
    prev_pos=pos;
 
941
  }
 
942
  row[field]=(char*) prev_pos+1;    /* End of last field */
 
943
  *prev_pos=0;          /* Terminate last field */
 
944
  return 0;
 
945
}
 
946
 
 
947
 
 
948
/****************************************************************************
 
949
  Init DRIZZLE structure or allocate one
 
950
****************************************************************************/
 
951
 
 
952
DRIZZLE *
 
953
drizzle_create(DRIZZLE *ptr)
 
954
{
 
955
 
 
956
  if (!drizzle_client_init)
 
957
  {
 
958
    drizzle_client_init=true;
 
959
    org_my_init_done=my_init_done;
 
960
 
 
961
    /* Will init threads */
 
962
    if (my_init())
 
963
      return NULL;
 
964
 
 
965
    if (!drizzle_port)
 
966
    {
 
967
      drizzle_port = DRIZZLE_PORT;
 
968
      {
 
969
        struct servent *serv_ptr;
 
970
        char *env;
 
971
 
 
972
        /*
 
973
          if builder specifically requested a default port, use that
 
974
          (even if it coincides with our factory default).
 
975
          only if they didn't do we check /etc/services (and, failing
 
976
          on that, fall back to the factory default of 4427).
 
977
          either default can be overridden by the environment variable
 
978
          DRIZZLE_TCP_PORT, which in turn can be overridden with command
 
979
          line options.
 
980
        */
 
981
 
 
982
#if DRIZZLE_PORT_DEFAULT == 0
 
983
        if ((serv_ptr = getservbyname("drizzle", "tcp")))
 
984
          drizzle_port = (uint) ntohs((ushort) serv_ptr->s_port);
 
985
#endif
 
986
        if ((env = getenv("DRIZZLE_TCP_PORT")))
 
987
          drizzle_port =(uint) atoi(env);
 
988
      }
 
989
    }
 
990
#if defined(SIGPIPE)
 
991
    (void) signal(SIGPIPE, SIG_IGN);
 
992
#endif
 
993
  }
 
994
  else
 
995
    /* Init if new thread */
 
996
    if (my_thread_init())
 
997
      return NULL;
 
998
 
 
999
  if (ptr == NULL)
 
1000
  {
 
1001
    ptr= (DRIZZLE *) malloc(sizeof(DRIZZLE));
 
1002
 
 
1003
    if (ptr == NULL)
 
1004
    {
 
1005
      set_drizzle_error(NULL, CR_OUT_OF_MEMORY, unknown_sqlstate);
 
1006
      return 0;
 
1007
    }
 
1008
    memset(ptr, 0, sizeof(DRIZZLE));
 
1009
    ptr->free_me=1;
 
1010
  }
 
1011
  else
 
1012
  {
 
1013
    memset(ptr, 0, sizeof(DRIZZLE)); 
 
1014
  }
 
1015
 
 
1016
  ptr->options.connect_timeout= CONNECT_TIMEOUT;
 
1017
  ptr->charset=default_client_charset_info;
 
1018
  strcpy(ptr->net.sqlstate, not_error_sqlstate);
 
1019
 
 
1020
  /*
 
1021
    Only enable LOAD DATA INFILE by default if configured with
 
1022
    --enable-local-infile
 
1023
  */
 
1024
 
 
1025
#if defined(ENABLED_LOCAL_INFILE) && !defined(DRIZZLE_SERVER)
 
1026
  ptr->options.client_flag|= CLIENT_LOCAL_FILES;
 
1027
#endif
 
1028
 
 
1029
  ptr->options.methods_to_use= DRIZZLE_OPT_GUESS_CONNECTION;
 
1030
  ptr->options.report_data_truncation= true;  /* default */
 
1031
 
 
1032
  /*
 
1033
    By default we don't reconnect because it could silently corrupt data (after
 
1034
    reconnection you potentially lose table locks, user variables, session
 
1035
    variables (transactions but they are specifically dealt with in
 
1036
    drizzle_reconnect()).
 
1037
    This is a change: < 5.0.3 drizzle->reconnect was set to 1 by default.
 
1038
    How this change impacts existing apps:
 
1039
    - existing apps which relyed on the default will see a behaviour change;
 
1040
    they will have to set reconnect=1 after drizzle_connect().
 
1041
    - existing apps which explicitely asked for reconnection (the only way they
 
1042
    could do it was by setting drizzle.reconnect to 1 after drizzle_connect())
 
1043
    will not see a behaviour change.
 
1044
    - existing apps which explicitely asked for no reconnection
 
1045
    (drizzle.reconnect=0) will not see a behaviour change.
 
1046
  */
 
1047
  ptr->reconnect= 0;
 
1048
 
 
1049
  return ptr;
 
1050
}
 
1051
 
 
1052
 
 
1053
/*
 
1054
  Free all memory and resources used by the client library
 
1055
 
 
1056
  NOTES
 
1057
    When calling this there should not be any other threads using
 
1058
    the library.
 
1059
 
 
1060
    To make things simpler when used with windows dll's (which calls this
 
1061
    function automaticly), it's safe to call this function multiple times.
 
1062
*/
 
1063
 
 
1064
 
 
1065
void drizzle_server_end()
 
1066
{
 
1067
  if (!drizzle_client_init)
 
1068
    return;
 
1069
 
 
1070
  vio_end();
 
1071
 
 
1072
  /* If library called my_init(), free memory allocated by it */
 
1073
  if (!org_my_init_done)
 
1074
  {
 
1075
    my_end(0);
 
1076
  }
 
1077
  else
 
1078
  {
 
1079
    free_charsets();
 
1080
    drizzle_thread_end();
 
1081
  }
 
1082
 
 
1083
  drizzle_client_init= org_my_init_done= 0;
 
1084
#ifdef EMBEDDED_SERVER
 
1085
  if (stderror_file)
 
1086
  {
 
1087
    fclose(stderror_file);
 
1088
    stderror_file= 0;
 
1089
  }
 
1090
#endif
 
1091
}
 
1092
 
 
1093
 
 
1094
/*
 
1095
  Fill in SSL part of DRIZZLE structure and set 'use_ssl' flag.
 
1096
  NB! Errors are not reported until you do drizzle_connect.
 
1097
*/
 
1098
 
 
1099
#define strdup_if_not_null(A) (A) == 0 ? 0 : my_strdup((A),MYF(MY_WME))
 
1100
 
 
1101
/*
 
1102
  Note that the drizzle argument must be initialized with drizzle_init()
 
1103
  before calling drizzle_connect !
 
1104
*/
 
1105
 
 
1106
static bool cli_read_query_result(DRIZZLE *drizzle);
 
1107
static DRIZZLE_RES *cli_use_result(DRIZZLE *drizzle);
 
1108
 
 
1109
static DRIZZLE_METHODS client_methods=
 
1110
{
 
1111
  cli_read_query_result,                       /* read_query_result */
 
1112
  cli_advanced_command,                        /* advanced_command */
 
1113
  cli_read_rows,                               /* read_rows */
 
1114
  cli_use_result,                              /* use_result */
 
1115
  cli_fetch_lengths,                           /* fetch_lengths */
 
1116
  cli_flush_use_result,                         /* flush_use_result */
 
1117
#ifndef DRIZZLE_SERVER
 
1118
  cli_list_fields,                            /* list_fields */
 
1119
  cli_unbuffered_fetch,                        /* unbuffered_fetch */
 
1120
  cli_read_statistics,                         /* read_statistics */
 
1121
  cli_read_query_result,                       /* next_result */
 
1122
  cli_read_change_user_result,                 /* read_change_user_result */
 
1123
#else
 
1124
  0,0,0,0,0
 
1125
#endif
 
1126
};
 
1127
 
 
1128
C_MODE_START
 
1129
int drizzle_init_character_set(DRIZZLE *drizzle)
 
1130
{
 
1131
  const char *default_collation_name;
 
1132
 
 
1133
  /* Set character set */
 
1134
  if (!drizzle->options.charset_name)
 
1135
  {
 
1136
    default_collation_name= DRIZZLE_DEFAULT_COLLATION_NAME;
 
1137
    if (!(drizzle->options.charset_name=
 
1138
       my_strdup(DRIZZLE_DEFAULT_CHARSET_NAME,MYF(MY_WME))))
 
1139
    return 1;
 
1140
  }
 
1141
  else
 
1142
    default_collation_name= NULL;
 
1143
 
 
1144
  {
 
1145
    const char *save= charsets_dir;
 
1146
    if (drizzle->options.charset_dir)
 
1147
      charsets_dir=drizzle->options.charset_dir;
 
1148
    drizzle->charset=get_charset_by_csname(drizzle->options.charset_name,
 
1149
                                         MY_CS_PRIMARY, MYF(MY_WME));
 
1150
    if (drizzle->charset && default_collation_name)
 
1151
    {
 
1152
      const CHARSET_INFO *collation;
 
1153
      if ((collation=
 
1154
           get_charset_by_name(default_collation_name, MYF(MY_WME))))
 
1155
      {
 
1156
        if (!my_charset_same(drizzle->charset, collation))
 
1157
        {
 
1158
          my_printf_error(ER_UNKNOWN_ERROR,
 
1159
                         _("COLLATION %s is not valid for CHARACTER SET %s"),
 
1160
                         MYF(0),
 
1161
                         default_collation_name, drizzle->options.charset_name);
 
1162
          drizzle->charset= NULL;
 
1163
        }
 
1164
        else
 
1165
        {
 
1166
          drizzle->charset= collation;
 
1167
        }
 
1168
      }
 
1169
      else
 
1170
        drizzle->charset= NULL;
 
1171
    }
 
1172
    charsets_dir= save;
 
1173
  }
 
1174
 
 
1175
  if (!drizzle->charset)
 
1176
  {
 
1177
    if (drizzle->options.charset_dir)
 
1178
      set_drizzle_extended_error(drizzle, CR_CANT_READ_CHARSET, unknown_sqlstate,
 
1179
                               ER(CR_CANT_READ_CHARSET),
 
1180
                               drizzle->options.charset_name,
 
1181
                               drizzle->options.charset_dir);
 
1182
    else
 
1183
    {
 
1184
      char cs_dir_name[FN_REFLEN];
 
1185
      get_charsets_dir(cs_dir_name);
 
1186
      set_drizzle_extended_error(drizzle, CR_CANT_READ_CHARSET, unknown_sqlstate,
 
1187
                               ER(CR_CANT_READ_CHARSET),
 
1188
                               drizzle->options.charset_name,
 
1189
                               cs_dir_name);
 
1190
    }
 
1191
    return 1;
 
1192
  }
 
1193
  return 0;
 
1194
}
 
1195
C_MODE_END
 
1196
 
 
1197
 
 
1198
DRIZZLE *
 
1199
CLI_DRIZZLE_CONNECT(DRIZZLE *drizzle,const char *host, const char *user,
 
1200
                       const char *passwd, const char *db,
 
1201
                       uint32_t port, const char *unix_socket, uint32_t client_flag)
 
1202
{
 
1203
  char          buff[NAME_LEN+USERNAME_LENGTH+100];
 
1204
  char          *end,*host_info=NULL;
 
1205
  uint32_t         pkt_length;
 
1206
  NET           *net= &drizzle->net;
 
1207
  init_sigpipe_variables
 
1208
 
 
1209
  /* Don't give sigpipe errors if the client doesn't want them */
 
1210
  set_sigpipe(drizzle);
 
1211
  drizzle->methods= &client_methods;
 
1212
  net->vio = 0;        /* If something goes wrong */
 
1213
  drizzle->client_flag=0;      /* For handshake */
 
1214
 
 
1215
  /* use default options */
 
1216
  if (drizzle->options.my_cnf_file || drizzle->options.my_cnf_group)
 
1217
  {
 
1218
    drizzle_read_default_options(&drizzle->options,
 
1219
             (drizzle->options.my_cnf_file ?
 
1220
        drizzle->options.my_cnf_file : "my"),
 
1221
             drizzle->options.my_cnf_group);
 
1222
    my_free(drizzle->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
 
1223
    my_free(drizzle->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
 
1224
    drizzle->options.my_cnf_file=drizzle->options.my_cnf_group=0;
 
1225
  }
 
1226
 
 
1227
  /* Some empty-string-tests are done because of ODBC */
 
1228
  if (!host || !host[0])
 
1229
    host=drizzle->options.host;
 
1230
  if (!user || !user[0])
 
1231
  {
 
1232
    user=drizzle->options.user;
 
1233
    if (!user)
 
1234
      user= "";
 
1235
  }
 
1236
  if (!passwd)
 
1237
  {
 
1238
    passwd=drizzle->options.password;
 
1239
    if (!passwd)
 
1240
      passwd= "";
 
1241
  }
 
1242
  if (!db || !db[0])
 
1243
    db=drizzle->options.db;
 
1244
  if (!port)
 
1245
    port=drizzle->options.port;
 
1246
  if (!unix_socket)
 
1247
    unix_socket=drizzle->options.unix_socket;
 
1248
 
 
1249
  drizzle->server_status=SERVER_STATUS_AUTOCOMMIT;
 
1250
 
 
1251
  /*
 
1252
    Part 0: Grab a socket and connect it to the server
 
1253
  */
 
1254
  if (!net->vio &&
 
1255
      (!drizzle->options.protocol ||
 
1256
       drizzle->options.protocol == DRIZZLE_PROTOCOL_TCP))
 
1257
  {
 
1258
    struct addrinfo *res_lst, hints, *t_res;
 
1259
    int gai_errno;
 
1260
    char port_buf[NI_MAXSERV];
 
1261
 
 
1262
    unix_socket=0;        /* This is not used */
 
1263
 
 
1264
    if (!port)
 
1265
      port= drizzle_port;
 
1266
 
 
1267
    if (!host)
 
1268
      host= LOCAL_HOST;
 
1269
 
 
1270
    snprintf(host_info=buff, sizeof(buff)-1, ER(CR_TCP_CONNECTION), host);
 
1271
 
 
1272
    memset(&hints, 0, sizeof(hints));
 
1273
    hints.ai_socktype= SOCK_STREAM;
 
1274
 
 
1275
    snprintf(port_buf, NI_MAXSERV, "%d", port);
 
1276
    gai_errno= getaddrinfo(host, port_buf, &hints, &res_lst);
 
1277
 
 
1278
    if (gai_errno != 0)
 
1279
    {
 
1280
      set_drizzle_extended_error(drizzle, CR_UNKNOWN_HOST, unknown_sqlstate,
 
1281
                                 ER(CR_UNKNOWN_HOST), host, errno);
 
1282
 
 
1283
      goto error;
 
1284
    }
 
1285
 
 
1286
    for (t_res= res_lst; t_res != NULL; t_res= t_res->ai_next)
 
1287
    {
 
1288
      int sock= socket(t_res->ai_family, t_res->ai_socktype,
 
1289
                       t_res->ai_protocol);
 
1290
      if (sock == SOCKET_ERROR)
 
1291
        continue;
 
1292
 
 
1293
      net->vio= vio_new(sock, VIO_TYPE_TCPIP, VIO_BUFFERED_READ);
 
1294
      if (! net->vio )
 
1295
      {
 
1296
        close(sock);
 
1297
        continue;
 
1298
      }
 
1299
 
 
1300
      if (connect_with_timeout(sock, t_res->ai_addr, t_res->ai_addrlen, drizzle->options.connect_timeout))
 
1301
      {
 
1302
        vio_delete(net->vio);
 
1303
        net->vio= 0;
 
1304
        continue;
 
1305
      }
 
1306
      break;
 
1307
    }
 
1308
 
 
1309
    freeaddrinfo(res_lst);
 
1310
  }
 
1311
 
 
1312
  if (!net->vio)
 
1313
  {
 
1314
    set_drizzle_extended_error(drizzle, CR_CONN_HOST_ERROR, unknown_sqlstate,
 
1315
                               ER(CR_CONN_HOST_ERROR), host, socket_errno);
 
1316
    goto error;
 
1317
  }
 
1318
 
 
1319
  if (my_net_init(net, net->vio))
 
1320
  {
 
1321
    vio_delete(net->vio);
 
1322
    net->vio = 0;
 
1323
    set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
 
1324
    goto error;
 
1325
  }
 
1326
  vio_keepalive(net->vio,true);
 
1327
 
 
1328
  /* If user set read_timeout, let it override the default */
 
1329
  if (drizzle->options.read_timeout)
 
1330
    my_net_set_read_timeout(net, drizzle->options.read_timeout);
 
1331
 
 
1332
  /* If user set write_timeout, let it override the default */
 
1333
  if (drizzle->options.write_timeout)
 
1334
    my_net_set_write_timeout(net, drizzle->options.write_timeout);
 
1335
 
 
1336
  if (drizzle->options.max_allowed_packet)
 
1337
    net->max_packet_size= drizzle->options.max_allowed_packet;
 
1338
 
 
1339
  /* Get version info */
 
1340
  drizzle->protocol_version= PROTOCOL_VERSION;  /* Assume this */
 
1341
  if (drizzle->options.connect_timeout &&
 
1342
      vio_poll_read(net->vio, drizzle->options.connect_timeout))
 
1343
  {
 
1344
    set_drizzle_extended_error(drizzle, CR_SERVER_LOST, unknown_sqlstate,
 
1345
                             ER(CR_SERVER_LOST_INITIAL_COMM_WAIT),
 
1346
                             errno);
 
1347
    goto error;
 
1348
  }
 
1349
 
 
1350
  /*
 
1351
    Part 1: Connection established, read and parse first packet
 
1352
  */
 
1353
 
 
1354
  if ((pkt_length=cli_safe_read(drizzle)) == packet_error)
 
1355
  {
 
1356
    if (drizzle->net.last_errno == CR_SERVER_LOST)
 
1357
      set_drizzle_extended_error(drizzle, CR_SERVER_LOST, unknown_sqlstate,
 
1358
                               ER(CR_SERVER_LOST_INITIAL_COMM_READ),
 
1359
                               errno);
 
1360
    goto error;
 
1361
  }
 
1362
  /* Check if version of protocol matches current one */
 
1363
 
 
1364
  drizzle->protocol_version= net->read_pos[0];
 
1365
  if (drizzle->protocol_version != PROTOCOL_VERSION)
 
1366
  {
 
1367
    set_drizzle_extended_error(drizzle, CR_VERSION_ERROR, unknown_sqlstate,
 
1368
                             ER(CR_VERSION_ERROR), drizzle->protocol_version,
 
1369
                             PROTOCOL_VERSION);
 
1370
    goto error;
 
1371
  }
 
1372
  end= strchr((char*) net->read_pos+1, '\0');
 
1373
  drizzle->thread_id=uint4korr(end+1);
 
1374
  end+=5;
 
1375
  /*
 
1376
    Scramble is split into two parts because old clients does not understand
 
1377
    long scrambles; here goes the first part.
 
1378
  */
 
1379
  strncpy(drizzle->scramble, end, SCRAMBLE_LENGTH_323);
 
1380
  end+= SCRAMBLE_LENGTH_323+1;
 
1381
 
 
1382
  if (pkt_length >= (uint) (end+1 - (char*) net->read_pos))
 
1383
    drizzle->server_capabilities=uint2korr(end);
 
1384
  if (pkt_length >= (uint) (end+18 - (char*) net->read_pos))
 
1385
  {
 
1386
    /* New protocol with 16 bytes to describe server characteristics */
 
1387
    drizzle->server_language=end[2];
 
1388
    drizzle->server_status=uint2korr(end+3);
 
1389
  }
 
1390
  end+= 18;
 
1391
  if (pkt_length >= (uint) (end + SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323 + 1 -
 
1392
                           (char *) net->read_pos))
 
1393
    strncpy(drizzle->scramble+SCRAMBLE_LENGTH_323, end,
 
1394
            SCRAMBLE_LENGTH-SCRAMBLE_LENGTH_323);
 
1395
  else
 
1396
    drizzle->server_capabilities&= ~CLIENT_SECURE_CONNECTION;
 
1397
 
 
1398
  if (drizzle->options.secure_auth && passwd[0] &&
 
1399
      !(drizzle->server_capabilities & CLIENT_SECURE_CONNECTION))
 
1400
  {
 
1401
    set_drizzle_error(drizzle, CR_SECURE_AUTH, unknown_sqlstate);
 
1402
    goto error;
 
1403
  }
 
1404
 
 
1405
  if (drizzle_init_character_set(drizzle))
 
1406
    goto error;
 
1407
 
 
1408
  /* Save connection information */
 
1409
  if (!my_multi_malloc(MYF(0),
 
1410
           &drizzle->host_info, (uint) strlen(host_info)+1,
 
1411
           &drizzle->host,      (uint) strlen(host)+1,
 
1412
           &drizzle->unix_socket,unix_socket ?
 
1413
           (uint) strlen(unix_socket)+1 : (uint) 1,
 
1414
           &drizzle->server_version,
 
1415
           (uint) (end - (char*) net->read_pos),
 
1416
           NullS) ||
 
1417
      !(drizzle->user=my_strdup(user,MYF(0))) ||
 
1418
      !(drizzle->passwd=my_strdup(passwd,MYF(0))))
 
1419
  {
 
1420
    set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
 
1421
    goto error;
 
1422
  }
 
1423
  strcpy(drizzle->host_info,host_info);
 
1424
  strcpy(drizzle->host,host);
 
1425
  if (unix_socket)
 
1426
    strcpy(drizzle->unix_socket,unix_socket);
 
1427
  else
 
1428
    drizzle->unix_socket=0;
 
1429
  strcpy(drizzle->server_version,(char*) net->read_pos+1);
 
1430
  drizzle->port=port;
 
1431
 
 
1432
  /*
 
1433
    Part 2: format and send client info to the server for access check
 
1434
  */
 
1435
 
 
1436
  client_flag|=drizzle->options.client_flag;
 
1437
  client_flag|=CLIENT_CAPABILITIES;
 
1438
  if (client_flag & CLIENT_MULTI_STATEMENTS)
 
1439
    client_flag|= CLIENT_MULTI_RESULTS;
 
1440
 
 
1441
  if (db)
 
1442
    client_flag|=CLIENT_CONNECT_WITH_DB;
 
1443
 
 
1444
  /* Remove options that server doesn't support */
 
1445
  client_flag= ((client_flag &
 
1446
     ~(CLIENT_COMPRESS | CLIENT_SSL)) |
 
1447
    (client_flag & drizzle->server_capabilities));
 
1448
  client_flag&= ~CLIENT_COMPRESS;
 
1449
 
 
1450
  int4store(buff, client_flag);
 
1451
  int4store(buff+4, net->max_packet_size);
 
1452
  buff[8]= (char) drizzle->charset->number;
 
1453
  memset(buff+9, 0, 32-9);
 
1454
  end= buff+32;
 
1455
 
 
1456
  drizzle->client_flag=client_flag;
 
1457
 
 
1458
  /* This needs to be changed as it's not useful with big packets */
 
1459
  if (user && user[0])
 
1460
    strncpy(end,user,USERNAME_LENGTH);          /* Max user name */
 
1461
  else
 
1462
    read_user_name((char*) end);
 
1463
 
 
1464
  /* We have to handle different version of handshake here */
 
1465
  end= strchr(end, '\0') + 1;
 
1466
  if (passwd[0])
 
1467
  {
 
1468
    {
 
1469
      *end++= SCRAMBLE_LENGTH;
 
1470
      memset(end, 0, SCRAMBLE_LENGTH-1);
 
1471
      memcpy(end, passwd, strlen(passwd));
 
1472
      end+= SCRAMBLE_LENGTH;
 
1473
    }
 
1474
  }
 
1475
  else
 
1476
    *end++= '\0';                               /* empty password */
 
1477
 
 
1478
  /* Add database if needed */
 
1479
  if (db && (drizzle->server_capabilities & CLIENT_CONNECT_WITH_DB))
 
1480
  {
 
1481
    end= strncpy(end, db, NAME_LEN) + NAME_LEN + 1;
 
1482
    drizzle->db= my_strdup(db,MYF(MY_WME));
 
1483
    db= 0;
 
1484
  }
 
1485
  /* Write authentication package */
 
1486
  if (my_net_write(net, (uchar*) buff, (size_t) (end-buff)) || net_flush(net))
 
1487
  {
 
1488
    set_drizzle_extended_error(drizzle, CR_SERVER_LOST, unknown_sqlstate,
 
1489
                             ER(CR_SERVER_LOST_SEND_AUTH),
 
1490
                             errno);
 
1491
    goto error;
 
1492
  }
 
1493
 
 
1494
  /*
 
1495
    Part 3: Authorization data's been sent. Now server can reply with
 
1496
    OK-packet, or re-request scrambled password.
 
1497
  */
 
1498
 
 
1499
  if ((pkt_length=cli_safe_read(drizzle)) == packet_error)
 
1500
  {
 
1501
    if (drizzle->net.last_errno == CR_SERVER_LOST)
 
1502
      set_drizzle_extended_error(drizzle, CR_SERVER_LOST, unknown_sqlstate,
 
1503
                               ER(CR_SERVER_LOST_READ_AUTH),
 
1504
                               errno);
 
1505
    goto error;
 
1506
  }
 
1507
 
 
1508
  if (client_flag & CLIENT_COMPRESS)    /* We will use compression */
 
1509
    net->compress=1;
 
1510
 
 
1511
 
 
1512
  if (db && drizzle_select_db(drizzle, db))
 
1513
  {
 
1514
    if (drizzle->net.last_errno == CR_SERVER_LOST)
 
1515
        set_drizzle_extended_error(drizzle, CR_SERVER_LOST, unknown_sqlstate,
 
1516
                                 ER(CR_SERVER_LOST_SETTING_DB),
 
1517
                                 errno);
 
1518
    goto error;
 
1519
  }
 
1520
 
 
1521
  if (drizzle->options.init_commands)
 
1522
  {
 
1523
    DYNAMIC_ARRAY *init_commands= drizzle->options.init_commands;
 
1524
    char **ptr= (char**)init_commands->buffer;
 
1525
    char **end_command= ptr + init_commands->elements;
 
1526
 
 
1527
    bool reconnect=drizzle->reconnect;
 
1528
    drizzle->reconnect=0;
 
1529
 
 
1530
    for (; ptr < end_command; ptr++)
 
1531
    {
 
1532
      DRIZZLE_RES *res;
 
1533
      if (drizzle_real_query(drizzle,*ptr, (uint32_t) strlen(*ptr)))
 
1534
  goto error;
 
1535
      if (drizzle->fields)
 
1536
      {
 
1537
  if (!(res= cli_use_result(drizzle)))
 
1538
    goto error;
 
1539
  drizzle_free_result(res);
 
1540
      }
 
1541
    }
 
1542
    drizzle->reconnect=reconnect;
 
1543
  }
 
1544
 
 
1545
  reset_sigpipe(drizzle);
 
1546
  return(drizzle);
 
1547
 
 
1548
error:
 
1549
  reset_sigpipe(drizzle);
 
1550
  {
 
1551
    /* Free alloced memory */
 
1552
    end_server(drizzle);
 
1553
    drizzle_close_free(drizzle);
 
1554
    if (!(((uint32_t) client_flag) & CLIENT_REMEMBER_OPTIONS))
 
1555
      drizzle_close_free_options(drizzle);
 
1556
  }
 
1557
  return(0);
 
1558
}
 
1559
 
 
1560
 
 
1561
bool drizzle_reconnect(DRIZZLE *drizzle)
 
1562
{
 
1563
  DRIZZLE tmp_drizzle;
 
1564
  assert(drizzle);
 
1565
 
 
1566
  if (!drizzle->reconnect ||
 
1567
      (drizzle->server_status & SERVER_STATUS_IN_TRANS) || !drizzle->host_info)
 
1568
  {
 
1569
    /* Allow reconnect next time */
 
1570
    drizzle->server_status&= ~SERVER_STATUS_IN_TRANS;
 
1571
    set_drizzle_error(drizzle, CR_SERVER_GONE_ERROR, unknown_sqlstate);
 
1572
    return(1);
 
1573
  }
 
1574
  drizzle_create(&tmp_drizzle);
 
1575
  tmp_drizzle.options= drizzle->options;
 
1576
  tmp_drizzle.options.my_cnf_file= tmp_drizzle.options.my_cnf_group= 0;
 
1577
 
 
1578
  if (!drizzle_connect(&tmp_drizzle,drizzle->host,drizzle->user,drizzle->passwd,
 
1579
        drizzle->db, drizzle->port, drizzle->unix_socket,
 
1580
        drizzle->client_flag | CLIENT_REMEMBER_OPTIONS))
 
1581
  {
 
1582
    drizzle->net.last_errno= tmp_drizzle.net.last_errno;
 
1583
    strcpy(drizzle->net.last_error, tmp_drizzle.net.last_error);
 
1584
    strcpy(drizzle->net.sqlstate, tmp_drizzle.net.sqlstate);
 
1585
    return(1);
 
1586
  }
 
1587
  if (drizzle_set_character_set(&tmp_drizzle, drizzle->charset->csname))
 
1588
  {
 
1589
    memset(&tmp_drizzle.options, 0, sizeof(tmp_drizzle.options));
 
1590
    drizzle_close(&tmp_drizzle);
 
1591
    drizzle->net.last_errno= tmp_drizzle.net.last_errno;
 
1592
    strcpy(drizzle->net.last_error, tmp_drizzle.net.last_error);
 
1593
    strcpy(drizzle->net.sqlstate, tmp_drizzle.net.sqlstate);
 
1594
    return(1);
 
1595
  }
 
1596
 
 
1597
  tmp_drizzle.reconnect= 1;
 
1598
  tmp_drizzle.free_me= drizzle->free_me;
 
1599
 
 
1600
  /* Don't free options as these are now used in tmp_drizzle */
 
1601
  memset(&drizzle->options, 0, sizeof(drizzle->options));
 
1602
  drizzle->free_me=0;
 
1603
  drizzle_close(drizzle);
 
1604
  *drizzle=tmp_drizzle;
 
1605
  net_clear(&drizzle->net, 1);
 
1606
  drizzle->affected_rows= ~(uint64_t) 0;
 
1607
  return(0);
 
1608
}
 
1609
 
 
1610
 
 
1611
/**************************************************************************
 
1612
  Set current database
 
1613
**************************************************************************/
 
1614
 
 
1615
int
 
1616
drizzle_select_db(DRIZZLE *drizzle, const char *db)
 
1617
{
 
1618
  int error;
 
1619
 
 
1620
  if ((error=simple_command(drizzle,COM_INIT_DB, (const uchar*) db,
 
1621
                            (uint32_t) strlen(db),0)))
 
1622
    return(error);
 
1623
  my_free(drizzle->db,MYF(MY_ALLOW_ZERO_PTR));
 
1624
  drizzle->db=my_strdup(db,MYF(MY_WME));
 
1625
  return(0);
 
1626
}
 
1627
 
 
1628
 
 
1629
/*************************************************************************
 
1630
  Send a QUIT to the server and close the connection
 
1631
  If handle is alloced by DRIZZLE connect free it.
 
1632
*************************************************************************/
 
1633
 
 
1634
static void drizzle_close_free_options(DRIZZLE *drizzle)
 
1635
{
 
1636
  my_free(drizzle->options.user,MYF(MY_ALLOW_ZERO_PTR));
 
1637
  my_free(drizzle->options.host,MYF(MY_ALLOW_ZERO_PTR));
 
1638
  my_free(drizzle->options.password,MYF(MY_ALLOW_ZERO_PTR));
 
1639
  my_free(drizzle->options.unix_socket,MYF(MY_ALLOW_ZERO_PTR));
 
1640
  my_free(drizzle->options.db,MYF(MY_ALLOW_ZERO_PTR));
 
1641
  my_free(drizzle->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
 
1642
  my_free(drizzle->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
 
1643
  my_free(drizzle->options.charset_dir,MYF(MY_ALLOW_ZERO_PTR));
 
1644
  my_free(drizzle->options.charset_name,MYF(MY_ALLOW_ZERO_PTR));
 
1645
  my_free(drizzle->options.client_ip,MYF(MY_ALLOW_ZERO_PTR));
 
1646
  if (drizzle->options.init_commands)
 
1647
  {
 
1648
    DYNAMIC_ARRAY *init_commands= drizzle->options.init_commands;
 
1649
    char **ptr= (char**)init_commands->buffer;
 
1650
    char **end= ptr + init_commands->elements;
 
1651
    for (; ptr<end; ptr++)
 
1652
      my_free(*ptr,MYF(MY_WME));
 
1653
    delete_dynamic(init_commands);
 
1654
    my_free((char*)init_commands,MYF(MY_WME));
 
1655
  }
 
1656
  memset(&drizzle->options, 0, sizeof(drizzle->options));
 
1657
  return;
 
1658
}
 
1659
 
 
1660
 
 
1661
static void drizzle_close_free(DRIZZLE *drizzle)
 
1662
{
 
1663
  my_free((uchar*) drizzle->host_info,MYF(MY_ALLOW_ZERO_PTR));
 
1664
  my_free(drizzle->user,MYF(MY_ALLOW_ZERO_PTR));
 
1665
  my_free(drizzle->passwd,MYF(MY_ALLOW_ZERO_PTR));
 
1666
  my_free(drizzle->db,MYF(MY_ALLOW_ZERO_PTR));
 
1667
  my_free(drizzle->info_buffer,MYF(MY_ALLOW_ZERO_PTR));
 
1668
  drizzle->info_buffer= 0;
 
1669
 
 
1670
  /* Clear pointers for better safety */
 
1671
  drizzle->host_info= drizzle->user= drizzle->passwd= drizzle->db= 0;
 
1672
}
 
1673
 
 
1674
 
 
1675
void drizzle_close(DRIZZLE *drizzle)
 
1676
{
 
1677
  if (drizzle)          /* Some simple safety */
 
1678
  {
 
1679
    /* If connection is still up, send a QUIT message */
 
1680
    if (drizzle->net.vio != 0)
 
1681
    {
 
1682
      free_old_query(drizzle);
 
1683
      drizzle->status=DRIZZLE_STATUS_READY; /* Force command */
 
1684
      drizzle->reconnect=0;
 
1685
      simple_command(drizzle,COM_QUIT,(uchar*) 0,0,1);
 
1686
      end_server(drizzle);      /* Sets drizzle->net.vio= 0 */
 
1687
    }
 
1688
    drizzle_close_free_options(drizzle);
 
1689
    drizzle_close_free(drizzle);
 
1690
    if (drizzle->free_me)
 
1691
      my_free((uchar*) drizzle,MYF(0));
 
1692
  }
 
1693
  return;
 
1694
}
 
1695
 
 
1696
 
 
1697
static bool cli_read_query_result(DRIZZLE *drizzle)
 
1698
{
 
1699
  uchar *pos;
 
1700
  uint32_t field_count;
 
1701
  DRIZZLE_DATA *fields;
 
1702
  uint32_t length;
 
1703
 
 
1704
  if ((length = cli_safe_read(drizzle)) == packet_error)
 
1705
    return(1);
 
1706
  free_old_query(drizzle);    /* Free old result */
 
1707
#ifdef DRIZZLE_CLIENT      /* Avoid warn of unused labels*/
 
1708
get_info:
 
1709
#endif
 
1710
  pos=(uchar*) drizzle->net.read_pos;
 
1711
  if ((field_count= net_field_length(&pos)) == 0)
 
1712
  {
 
1713
    drizzle->affected_rows= net_field_length_ll(&pos);
 
1714
    drizzle->insert_id=    net_field_length_ll(&pos);
 
1715
 
 
1716
    drizzle->server_status= uint2korr(pos); pos+=2;
 
1717
    drizzle->warning_count= uint2korr(pos); pos+=2;
 
1718
 
 
1719
    if (pos < drizzle->net.read_pos+length && net_field_length(&pos))
 
1720
      drizzle->info=(char*) pos;
 
1721
    return(0);
 
1722
  }
 
1723
#ifdef DRIZZLE_CLIENT
 
1724
  if (field_count == NULL_LENGTH)    /* LOAD DATA LOCAL INFILE */
 
1725
  {
 
1726
    int error;
 
1727
 
 
1728
    if (!(drizzle->options.client_flag & CLIENT_LOCAL_FILES))
 
1729
    {
 
1730
      set_drizzle_error(drizzle, CR_MALFORMED_PACKET, unknown_sqlstate);
 
1731
      return(1);
 
1732
    }  
 
1733
 
 
1734
    error= handle_local_infile(drizzle,(char*) pos);
 
1735
    if ((length= cli_safe_read(drizzle)) == packet_error || error)
 
1736
      return(1);
 
1737
    goto get_info;        /* Get info packet */
 
1738
  }
 
1739
#endif
 
1740
  if (!(drizzle->server_status & SERVER_STATUS_AUTOCOMMIT))
 
1741
    drizzle->server_status|= SERVER_STATUS_IN_TRANS;
 
1742
 
 
1743
  if (!(fields=cli_read_rows(drizzle,(DRIZZLE_FIELD*)0, 7)))
 
1744
    return(1);
 
1745
  if (!(drizzle->fields= unpack_fields(fields,&drizzle->field_alloc,
 
1746
            (uint) field_count, 0)))
 
1747
    return(1);
 
1748
  drizzle->status= DRIZZLE_STATUS_GET_RESULT;
 
1749
  drizzle->field_count= (uint) field_count;
 
1750
  return(0);
 
1751
}
 
1752
 
 
1753
 
 
1754
/*
 
1755
  Send the query and return so we can do something else.
 
1756
  Needs to be followed by drizzle_read_query_result() when we want to
 
1757
  finish processing it.
 
1758
*/
 
1759
 
 
1760
int32_t
 
1761
drizzle_send_query(DRIZZLE *drizzle, const char* query, uint32_t length)
 
1762
{
 
1763
  return(simple_command(drizzle, COM_QUERY, (uchar*) query, length, 1));
 
1764
}
 
1765
 
 
1766
 
 
1767
int32_t
 
1768
drizzle_real_query(DRIZZLE *drizzle, const char *query, uint32_t length)
 
1769
{
 
1770
  if (drizzle_send_query(drizzle,query,length))
 
1771
    return(1);
 
1772
  return((int) (*drizzle->methods->read_query_result)(drizzle));
 
1773
}
 
1774
 
 
1775
 
 
1776
/**************************************************************************
 
1777
  Alloc result struct for buffered results. All rows are read to buffer.
 
1778
  drizzle_data_seek may be used.
 
1779
**************************************************************************/
 
1780
 
 
1781
DRIZZLE_RES * drizzle_store_result(DRIZZLE *drizzle)
 
1782
{
 
1783
  DRIZZLE_RES *result;
 
1784
 
 
1785
  if (!drizzle->fields)
 
1786
    return(0);
 
1787
  if (drizzle->status != DRIZZLE_STATUS_GET_RESULT)
 
1788
  {
 
1789
    set_drizzle_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
 
1790
    return(0);
 
1791
  }
 
1792
  drizzle->status=DRIZZLE_STATUS_READY;    /* server is ready */
 
1793
  if (!(result=(DRIZZLE_RES*) my_malloc((uint) (sizeof(DRIZZLE_RES)+
 
1794
                sizeof(uint32_t) *
 
1795
                drizzle->field_count),
 
1796
              MYF(MY_WME | MY_ZEROFILL))))
 
1797
  {
 
1798
    set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
 
1799
    return(0);
 
1800
  }
 
1801
  result->methods= drizzle->methods;
 
1802
  result->eof= 1;        /* Marker for buffered */
 
1803
  result->lengths= (uint32_t*) (result+1);
 
1804
  if (!(result->data=
 
1805
  (*drizzle->methods->read_rows)(drizzle,drizzle->fields,drizzle->field_count)))
 
1806
  {
 
1807
    my_free((uchar*) result,MYF(0));
 
1808
    return(0);
 
1809
  }
 
1810
  drizzle->affected_rows= result->row_count= result->data->rows;
 
1811
  result->data_cursor=  result->data->data;
 
1812
  result->fields=  drizzle->fields;
 
1813
  result->field_alloc=  drizzle->field_alloc;
 
1814
  result->field_count=  drizzle->field_count;
 
1815
  /* The rest of result members is zeroed in malloc */
 
1816
  drizzle->fields=0;        /* fields is now in result */
 
1817
  clear_alloc_root(&drizzle->field_alloc);
 
1818
  /* just in case this was mistakenly called after drizzle_stmt_execute() */
 
1819
  drizzle->unbuffered_fetch_owner= 0;
 
1820
  return(result);        /* Data fetched */
 
1821
}
 
1822
 
 
1823
 
 
1824
/**************************************************************************
 
1825
  Alloc struct for use with unbuffered reads. Data is fetched by domand
 
1826
  when calling to drizzle_fetch_row.
 
1827
  DRIZZLE_DATA_seek is a noop.
 
1828
 
 
1829
  No other queries may be specified with the same DRIZZLE handle.
 
1830
  There shouldn't be much processing per row because DRIZZLE server shouldn't
 
1831
  have to wait for the client (and will not wait more than 30 sec/packet).
 
1832
**************************************************************************/
 
1833
 
 
1834
static DRIZZLE_RES * cli_use_result(DRIZZLE *drizzle)
 
1835
{
 
1836
  DRIZZLE_RES *result;
 
1837
 
 
1838
  if (!drizzle->fields)
 
1839
    return(0);
 
1840
  if (drizzle->status != DRIZZLE_STATUS_GET_RESULT)
 
1841
  {
 
1842
    set_drizzle_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
 
1843
    return(0);
 
1844
  }
 
1845
  if (!(result=(DRIZZLE_RES*) my_malloc(sizeof(*result)+
 
1846
              sizeof(uint32_t)*drizzle->field_count,
 
1847
              MYF(MY_WME | MY_ZEROFILL))))
 
1848
    return(0);
 
1849
  result->lengths=(uint32_t*) (result+1);
 
1850
  result->methods= drizzle->methods;
 
1851
  if (!(result->row=(DRIZZLE_ROW)
 
1852
  my_malloc(sizeof(result->row[0])*(drizzle->field_count+1), MYF(MY_WME))))
 
1853
  {          /* Ptrs: to one row */
 
1854
    my_free((uchar*) result,MYF(0));
 
1855
    return(0);
 
1856
  }
 
1857
  result->fields=  drizzle->fields;
 
1858
  result->field_alloc=  drizzle->field_alloc;
 
1859
  result->field_count=  drizzle->field_count;
 
1860
  result->current_field=0;
 
1861
  result->handle=  drizzle;
 
1862
  result->current_row=  0;
 
1863
  drizzle->fields=0;      /* fields is now in result */
 
1864
  clear_alloc_root(&drizzle->field_alloc);
 
1865
  drizzle->status=DRIZZLE_STATUS_USE_RESULT;
 
1866
  drizzle->unbuffered_fetch_owner= &result->unbuffered_fetch_cancelled;
 
1867
  return(result);      /* Data is read to be fetched */
 
1868
}
 
1869
 
 
1870
 
 
1871
/**************************************************************************
 
1872
  Return next row of the query results
 
1873
**************************************************************************/
 
1874
 
 
1875
DRIZZLE_ROW
 
1876
drizzle_fetch_row(DRIZZLE_RES *res)
 
1877
{
 
1878
  if (!res->data)
 
1879
  {            /* Unbufferred fetch */
 
1880
    if (!res->eof)
 
1881
    {
 
1882
      DRIZZLE *drizzle= res->handle;
 
1883
      if (drizzle->status != DRIZZLE_STATUS_USE_RESULT)
 
1884
      {
 
1885
        set_drizzle_error(drizzle,
 
1886
                        res->unbuffered_fetch_cancelled ?
 
1887
                        CR_FETCH_CANCELED : CR_COMMANDS_OUT_OF_SYNC,
 
1888
                        unknown_sqlstate);
 
1889
      }
 
1890
      else if (!(read_one_row(drizzle, res->field_count, res->row, res->lengths)))
 
1891
      {
 
1892
  res->row_count++;
 
1893
  return(res->current_row=res->row);
 
1894
      }
 
1895
      res->eof=1;
 
1896
      drizzle->status=DRIZZLE_STATUS_READY;
 
1897
      /*
 
1898
        Reset only if owner points to us: there is a chance that somebody
 
1899
        started new query after drizzle_stmt_close():
 
1900
      */
 
1901
      if (drizzle->unbuffered_fetch_owner == &res->unbuffered_fetch_cancelled)
 
1902
        drizzle->unbuffered_fetch_owner= 0;
 
1903
      /* Don't clear handle in drizzle_free_result */
 
1904
      res->handle=0;
 
1905
    }
 
1906
    return((DRIZZLE_ROW) NULL);
 
1907
  }
 
1908
  {
 
1909
    DRIZZLE_ROW tmp;
 
1910
    if (!res->data_cursor)
 
1911
    {
 
1912
      return(res->current_row=(DRIZZLE_ROW) NULL);
 
1913
    }
 
1914
    tmp = res->data_cursor->data;
 
1915
    res->data_cursor = res->data_cursor->next;
 
1916
    return(res->current_row=tmp);
 
1917
  }
 
1918
}
 
1919
 
 
1920
 
 
1921
/**************************************************************************
 
1922
  Get column lengths of the current row
 
1923
  If one uses drizzle_use_result, res->lengths contains the length information,
 
1924
  else the lengths are calculated from the offset between pointers.
 
1925
**************************************************************************/
 
1926
 
 
1927
uint32_t *
 
1928
drizzle_fetch_lengths(DRIZZLE_RES *res)
 
1929
{
 
1930
  DRIZZLE_ROW column;
 
1931
 
 
1932
  if (!(column=res->current_row))
 
1933
    return 0;          /* Something is wrong */
 
1934
  if (res->data)
 
1935
    (*res->methods->fetch_lengths)(res->lengths, column, res->field_count);
 
1936
  return res->lengths;
 
1937
}
 
1938
 
 
1939
 
 
1940
int
 
1941
drizzle_options(DRIZZLE *drizzle,enum drizzle_option option, const void *arg)
 
1942
{
 
1943
  switch (option) {
 
1944
  case DRIZZLE_OPT_CONNECT_TIMEOUT:
 
1945
    drizzle->options.connect_timeout= *(uint*) arg;
 
1946
    break;
 
1947
  case DRIZZLE_OPT_READ_TIMEOUT:
 
1948
    drizzle->options.read_timeout= *(uint*) arg;
 
1949
    break;
 
1950
  case DRIZZLE_OPT_WRITE_TIMEOUT:
 
1951
    drizzle->options.write_timeout= *(uint*) arg;
 
1952
    break;
 
1953
  case DRIZZLE_OPT_COMPRESS:
 
1954
    drizzle->options.compress= 1;      /* Remember for connect */
 
1955
    drizzle->options.client_flag|= CLIENT_COMPRESS;
 
1956
    break;
 
1957
  case DRIZZLE_OPT_LOCAL_INFILE:      /* Allow LOAD DATA LOCAL ?*/
 
1958
    if (!arg || test(*(uint*) arg))
 
1959
      drizzle->options.client_flag|= CLIENT_LOCAL_FILES;
 
1960
    else
 
1961
      drizzle->options.client_flag&= ~CLIENT_LOCAL_FILES;
 
1962
    break;
 
1963
  case DRIZZLE_INIT_COMMAND:
 
1964
    add_init_command(&drizzle->options,arg);
 
1965
    break;
 
1966
  case DRIZZLE_READ_DEFAULT_FILE:
 
1967
    my_free(drizzle->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
 
1968
    drizzle->options.my_cnf_file=my_strdup(arg,MYF(MY_WME));
 
1969
    break;
 
1970
  case DRIZZLE_READ_DEFAULT_GROUP:
 
1971
    my_free(drizzle->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
 
1972
    drizzle->options.my_cnf_group=my_strdup(arg,MYF(MY_WME));
 
1973
    break;
 
1974
  case DRIZZLE_SET_CHARSET_DIR:
 
1975
    my_free(drizzle->options.charset_dir,MYF(MY_ALLOW_ZERO_PTR));
 
1976
    drizzle->options.charset_dir=my_strdup(arg,MYF(MY_WME));
 
1977
    break;
 
1978
  case DRIZZLE_SET_CHARSET_NAME:
 
1979
    my_free(drizzle->options.charset_name,MYF(MY_ALLOW_ZERO_PTR));
 
1980
    drizzle->options.charset_name=my_strdup(arg,MYF(MY_WME));
 
1981
    break;
 
1982
  case DRIZZLE_OPT_PROTOCOL:
 
1983
    drizzle->options.protocol= *(const uint*) arg;
 
1984
    break;
 
1985
  case DRIZZLE_OPT_USE_REMOTE_CONNECTION:
 
1986
  case DRIZZLE_OPT_GUESS_CONNECTION:
 
1987
    drizzle->options.methods_to_use= option;
 
1988
    break;
 
1989
  case DRIZZLE_SET_CLIENT_IP:
 
1990
    drizzle->options.client_ip= my_strdup(arg, MYF(MY_WME));
 
1991
    break;
 
1992
  case DRIZZLE_SECURE_AUTH:
 
1993
    drizzle->options.secure_auth= *(const bool *) arg;
 
1994
    break;
 
1995
  case DRIZZLE_REPORT_DATA_TRUNCATION:
 
1996
    drizzle->options.report_data_truncation= test(*(const bool *) arg);
 
1997
    break;
 
1998
  case DRIZZLE_OPT_RECONNECT:
 
1999
    drizzle->reconnect= *(const bool *) arg;
 
2000
    break;
 
2001
  case DRIZZLE_OPT_SSL_VERIFY_SERVER_CERT:
 
2002
    if (*(const bool*) arg)
 
2003
      drizzle->options.client_flag|= CLIENT_SSL_VERIFY_SERVER_CERT;
 
2004
    else
 
2005
      drizzle->options.client_flag&= ~CLIENT_SSL_VERIFY_SERVER_CERT;
 
2006
    break;
 
2007
  default:
 
2008
    return(1);
 
2009
  }
 
2010
  return(0);
 
2011
}
 
2012
 
 
2013
 
 
2014
/****************************************************************************
 
2015
  Functions to get information from the DRIZZLE structure
 
2016
  These are functions to make shared libraries more usable.
 
2017
****************************************************************************/
 
2018
 
 
2019
/* DRIZZLE_RES */
 
2020
uint64_t drizzle_num_rows(const DRIZZLE_RES *res)
 
2021
{
 
2022
  return res->row_count;
 
2023
}
 
2024
 
 
2025
unsigned int drizzle_num_fields(const DRIZZLE_RES *res)
 
2026
{
 
2027
  return res->field_count;
 
2028
}
 
2029
 
 
2030
uint drizzle_errno(const DRIZZLE *drizzle)
 
2031
{
 
2032
  return drizzle ? drizzle->net.last_errno : drizzle_server_last_errno;
 
2033
}
 
2034
 
 
2035
 
 
2036
const char * drizzle_error(const DRIZZLE *drizzle)
 
2037
{
 
2038
  return drizzle ? _(drizzle->net.last_error) : _(drizzle_server_last_error);
 
2039
}
 
2040
 
 
2041
 
 
2042
/*
 
2043
  Get version number for server in a form easy to test on
 
2044
 
 
2045
  SYNOPSIS
 
2046
    drizzle_get_server_version()
 
2047
    drizzle Connection
 
2048
 
 
2049
  EXAMPLE
 
2050
    4.1.0-alfa ->  40100
 
2051
 
 
2052
  NOTES
 
2053
    We will ensure that a newer server always has a bigger number.
 
2054
 
 
2055
  RETURN
 
2056
   Signed number > 323000
 
2057
*/
 
2058
 
 
2059
uint32_t
 
2060
drizzle_get_server_version(const DRIZZLE *drizzle)
 
2061
{
 
2062
  uint major, minor, version;
 
2063
  char *pos= drizzle->server_version, *end_pos;
 
2064
  major=   (uint) strtoul(pos, &end_pos, 10);  pos=end_pos+1;
 
2065
  minor=   (uint) strtoul(pos, &end_pos, 10);  pos=end_pos+1;
 
2066
  version= (uint) strtoul(pos, &end_pos, 10);
 
2067
  return (uint32_t) major*10000L+(uint32_t) (minor*100+version);
 
2068
}
 
2069
 
 
2070
 
 
2071
/*
 
2072
   drizzle_set_character_set function sends SET NAMES cs_name to
 
2073
   the server (which changes character_set_client, character_set_result
 
2074
   and character_set_connection) and updates drizzle->charset so other
 
2075
   functions like drizzle_real_escape will work correctly.
 
2076
*/
 
2077
int drizzle_set_character_set(DRIZZLE *drizzle, const char *cs_name)
 
2078
{
 
2079
  const CHARSET_INFO *cs;
 
2080
  const char *save_csdir= charsets_dir;
 
2081
 
 
2082
  if (drizzle->options.charset_dir)
 
2083
    charsets_dir= drizzle->options.charset_dir;
 
2084
 
 
2085
  if (strlen(cs_name) < MY_CS_NAME_SIZE &&
 
2086
      (cs= get_charset_by_csname(cs_name, MY_CS_PRIMARY, MYF(0))))
 
2087
  {
 
2088
    char buff[MY_CS_NAME_SIZE + 10];
 
2089
    charsets_dir= save_csdir;
 
2090
    sprintf(buff, "SET NAMES %s", cs_name);
 
2091
    if (!drizzle_real_query(drizzle, buff, strlen(buff)))
 
2092
    {
 
2093
      drizzle->charset= cs;
 
2094
    }
 
2095
  }
 
2096
  else
 
2097
  {
 
2098
    char cs_dir_name[FN_REFLEN];
 
2099
    get_charsets_dir(cs_dir_name);
 
2100
    set_drizzle_extended_error(drizzle, CR_CANT_READ_CHARSET, unknown_sqlstate,
 
2101
                             ER(CR_CANT_READ_CHARSET), cs_name, cs_dir_name);
 
2102
  }
 
2103
  charsets_dir= save_csdir;
 
2104
  return drizzle->net.last_errno;
 
2105
}
 
2106
 
 
2107