← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/client.c

Small fixes

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 Sun Microsystems, Inc.
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; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
/*
21
 
  This file is included by both libdrizzle.c (the DRIZZLE client C API)
22
 
  and the drizzled server to connect to another DRIZZLE server.
23
 
 
24
 
  The differences for the two cases are:
25
 
 
26
 
  - Things that only works for the client:
27
 
  - Trying to automaticly determinate user name if not supplied to
28
 
    drizzle_connect()
29
 
  - Support for reading local file with LOAD DATA LOCAL
30
 
  - SHARED memory handling
31
 
  - Prepared statements
32
 
 
33
 
  - Things that only works for the server
34
 
  - Alarm handling on connect
35
 
 
36
 
  In all other cases, the code should be idential for the client and
37
 
  server.
38
 
*/
39
 
 
40
 
#include <stdarg.h>
41
 
 
42
 
#include <libdrizzle/libdrizzle.h>
43
 
#include <libdrizzle/net_serv.h>
44
 
#include "libdrizzle_priv.h"
45
 
#include <libdrizzle/pack.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
 
#include <libdrizzle/errmsg.h>
57
 
 
58
 
#include <sys/stat.h>
59
 
#include <signal.h>
60
 
#include <time.h>
61
 
#ifdef   HAVE_PWD_H
62
 
#include <pwd.h>
63
 
#endif
64
 
 
65
 
#include <sys/socket.h>
66
 
#include <netinet/in.h>
67
 
#include <arpa/inet.h>
68
 
#include <netdb.h>
69
 
#ifdef HAVE_SELECT_H
70
 
#  include <select.h>
71
 
#endif
72
 
#ifdef HAVE_SYS_SELECT_H
73
 
#include <sys/select.h>
74
 
#endif
75
 
 
76
 
#include <sys/un.h>
77
 
 
78
 
#include <errno.h>
79
 
 
80
 
 
81
 
#include <drizzled/gettext.h>
82
 
#include "local_infile.h"
83
 
 
84
 
 
85
 
 
86
 
 
87
 
 
88
 
 
89
 
 
90
 
 
91
 
#if defined(HAVE_GETPWUID) && defined(NO_GETPWUID_DECL)
92
 
struct passwd *getpwuid(uid_t);
93
 
char* getlogin(void);
94
 
#endif
95
 
 
96
 
 
97
 
 
98
 
/*****************************************************************************
99
 
  Read a packet from server. Give error message if socket was down
100
 
  or packet is an error message
101
 
*****************************************************************************/
102
 
safe_read_error_hook_func safe_read_error_hook= NULL;
103
 
 
104
 
uint32_t cli_safe_read(DRIZZLE *drizzle)
105
 
{
106
 
  NET *net= &drizzle->net;
107
 
  uint32_t len=0;
108
 
 
109
 
  if (net->vio != 0)
110
 
    len=my_net_read(net);
111
 
 
112
 
  if (len == packet_error || len == 0)
113
 
  {
114
 
    if (safe_read_error_hook != NULL)
115
 
      if (safe_read_error_hook(net))
116
 
        return (packet_error);
117
 
    drizzle_disconnect(drizzle);
118
 
    drizzle_set_error(drizzle, net->last_errno == CR_NET_PACKET_TOO_LARGE ?
119
 
                      CR_NET_PACKET_TOO_LARGE : CR_SERVER_LOST,
120
 
                      sqlstate_get_unknown());
121
 
    return (packet_error);
122
 
  }
123
 
  if (net->read_pos[0] == 255)
124
 
  {
125
 
    if (len > 3)
126
 
    {
127
 
      char *pos=(char*) net->read_pos+1;
128
 
      net->last_errno=uint2korr(pos);
129
 
      pos+=2;
130
 
      len-=2;
131
 
      if (pos[0] == '#')
132
 
      {
133
 
        strncpy(net->sqlstate, pos+1, LIBDRIZZLE_SQLSTATE_LENGTH);
134
 
        pos+= LIBDRIZZLE_SQLSTATE_LENGTH+1;
135
 
      }
136
 
      else
137
 
      {
138
 
        /*
139
 
          The SQL state hasn't been received -- it should be reset to HY000
140
 
          (unknown error sql state).
141
 
        */
142
 
 
143
 
        strcpy(net->sqlstate, sqlstate_get_unknown());
144
 
      }
145
 
 
146
 
      strncpy(net->last_error,(char*) pos, min((uint32_t) len,
147
 
              (uint32_t) sizeof(net->last_error)-1));
148
 
    }
149
 
    else
150
 
      drizzle_set_error(drizzle, CR_UNKNOWN_ERROR, sqlstate_get_unknown());
151
 
    /*
152
 
      Cover a protocol design error: error packet does not
153
 
      contain the server status. Therefore, the client has no way
154
 
      to find out whether there are more result sets of
155
 
      a multiple-result-set statement pending. Luckily, in 5.0 an
156
 
      error always aborts execution of a statement, wherever it is
157
 
      a multi-statement or a stored procedure, so it should be
158
 
      safe to unconditionally turn off the flag here.
159
 
    */
160
 
    drizzle->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
161
 
 
162
 
    return(packet_error);
163
 
  }
164
 
  return len;
165
 
}
166
 
 
167
 
bool
168
 
cli_advanced_command(DRIZZLE *drizzle, enum enum_server_command command,
169
 
         const unsigned char *header, uint32_t header_length,
170
 
         const unsigned char *arg, uint32_t arg_length, bool skip_check)
171
 
{
172
 
  NET *net= &drizzle->net;
173
 
  bool result= 1;
174
 
  bool stmt_skip= false;
175
 
 
176
 
  if (drizzle->net.vio == 0)
177
 
  {            /* Do reconnect if possible */
178
 
    if (drizzle_reconnect(drizzle) || stmt_skip)
179
 
      return(1);
180
 
  }
181
 
  if (drizzle->status != DRIZZLE_STATUS_READY ||
182
 
      drizzle->server_status & SERVER_MORE_RESULTS_EXISTS)
183
 
  {
184
 
    drizzle_set_error(drizzle, CR_COMMANDS_OUT_OF_SYNC,
185
 
                      sqlstate_get_unknown());
186
 
    return(1);
187
 
  }
188
 
 
189
 
  net_clear_error(net);
190
 
  drizzle->info=0;
191
 
  drizzle->affected_rows= ~(uint64_t) 0;
192
 
  /*
193
 
    We don't want to clear the protocol buffer on COM_QUIT, because if
194
 
    the previous command was a shutdown command, we may have the
195
 
    response for the COM_QUIT already in the communication buffer
196
 
  */
197
 
  net_clear(&drizzle->net, (command != COM_QUIT));
198
 
 
199
 
  if (net_write_command(net,(unsigned char) command, header, header_length,
200
 
      arg, arg_length))
201
 
  {
202
 
    if (net->last_errno == CR_NET_PACKET_TOO_LARGE)
203
 
    {
204
 
      drizzle_set_error(drizzle, CR_NET_PACKET_TOO_LARGE, sqlstate_get_unknown());
205
 
      goto end;
206
 
    }
207
 
    drizzle_disconnect(drizzle);
208
 
    if (drizzle_reconnect(drizzle) || stmt_skip)
209
 
      goto end;
210
 
    if (net_write_command(net,(unsigned char) command, header, header_length,
211
 
        arg, arg_length))
212
 
    {
213
 
      drizzle_set_error(drizzle, CR_SERVER_GONE_ERROR, sqlstate_get_unknown());
214
 
      goto end;
215
 
    }
216
 
  }
217
 
  result=0;
218
 
  if (!skip_check)
219
 
    result= ((drizzle->packet_length=cli_safe_read(drizzle)) == packet_error ?
220
 
       1 : 0);
221
 
end:
222
 
  return(result);
223
 
}
224
 
 
225
 
void free_old_query(DRIZZLE *drizzle)
226
 
{
227
 
  if (drizzle->fields)
228
 
  {
229
 
    /* TODO - we need to de-alloc field storage */
230
 
    free(drizzle->fields->catalog);
231
 
    free(drizzle->fields->db);
232
 
    free(drizzle->fields->table);
233
 
    free(drizzle->fields->org_table);
234
 
    free(drizzle->fields->name);
235
 
    free(drizzle->fields->org_name);
236
 
    free(drizzle->fields->def);
237
 
    free(drizzle->fields);
238
 
 
239
 
  }
240
 
  /* init_alloc_root(&drizzle->field_alloc,8192,0); */ /* Assume rowlength < 8192 */
241
 
  drizzle->fields= 0;
242
 
  drizzle->field_count= 0;      /* For API */
243
 
  drizzle->warning_count= 0;
244
 
  drizzle->info= 0;
245
 
  return;
246
 
}
247
 
 
248
 
 
249
 
 
250
 
 
251
 
 
252
 
void
253
 
drizzle_free_result(DRIZZLE_RES *result)
254
 
{
255
 
  if (result)
256
 
  {
257
 
    DRIZZLE *drizzle= result->handle;
258
 
    if (drizzle)
259
 
    {
260
 
      if (drizzle->unbuffered_fetch_owner == &result->unbuffered_fetch_cancelled)
261
 
        drizzle->unbuffered_fetch_owner= 0;
262
 
      if (drizzle->status == DRIZZLE_STATUS_USE_RESULT)
263
 
      {
264
 
        (*drizzle->methods->flush_use_result)(drizzle);
265
 
        drizzle->status=DRIZZLE_STATUS_READY;
266
 
        if (drizzle->unbuffered_fetch_owner)
267
 
          *drizzle->unbuffered_fetch_owner= true;
268
 
      }
269
 
    }
270
 
    free_rows(result->data);
271
 
    /* TODO: free result->fields */
272
 
    if (result->row)
273
 
      free((unsigned char*) result->row);
274
 
    free((unsigned char*) result);
275
 
  }
276
 
}
277
 
 
278
 
 
279
 
 
280
 
 
281
 
/* Read all rows (fields or data) from server */
282
 
 
283
 
DRIZZLE_DATA *cli_read_rows(DRIZZLE *drizzle, DRIZZLE_FIELD *DRIZZLE_FIELDs, uint32_t fields)
284
 
{
285
 
  uint32_t  field;
286
 
  uint32_t pkt_len;
287
 
  uint32_t len;
288
 
  unsigned char *cp;
289
 
  char  *to, *end_to;
290
 
  DRIZZLE_DATA *result;
291
 
  DRIZZLE_ROWS **prev_ptr,*cur;
292
 
  NET *net = &drizzle->net;
293
 
 
294
 
  if ((pkt_len= cli_safe_read(drizzle)) == packet_error)
295
 
    return(0);
296
 
  if (!(result=(DRIZZLE_DATA*) malloc(sizeof(DRIZZLE_DATA))))
297
 
  {
298
 
    drizzle_set_error(drizzle, CR_OUT_OF_MEMORY,
299
 
                      sqlstate_get_unknown());
300
 
    return(0);
301
 
  }
302
 
  memset(result, 0, sizeof(DRIZZLE_DATA));
303
 
  prev_ptr= &result->data;
304
 
  result->rows=0;
305
 
  result->fields=fields;
306
 
 
307
 
  /*
308
 
    The last EOF packet is either a 254 (0xFE) character followed by 1-7 status bytes.
309
 
 
310
 
    This doesn't conflict with normal usage of 254 which stands for a
311
 
    string where the length of the string is 8 bytes. (see net_field_length())
312
 
  */
313
 
 
314
 
  while (*(cp=net->read_pos) != DRIZZLE_PROTOCOL_NO_MORE_DATA || pkt_len >= 8)
315
 
  {
316
 
    result->rows++;
317
 
    if (!(cur= (DRIZZLE_ROWS*) malloc(sizeof(DRIZZLE_ROWS))) ||
318
 
        !(cur->data= ((DRIZZLE_ROW) malloc((fields+1)*sizeof(char *)+pkt_len))))
319
 
    {
320
 
      free_rows(result);
321
 
      drizzle_set_error(drizzle, CR_OUT_OF_MEMORY, sqlstate_get_unknown());
322
 
      return(0);
323
 
    }
324
 
    *prev_ptr=cur;
325
 
    prev_ptr= &cur->next;
326
 
    to= (char*) (cur->data+fields+1);
327
 
    end_to=to+pkt_len-1;
328
 
    for (field=0 ; field < fields ; field++)
329
 
    {
330
 
      if ((len= net_field_length(&cp)) == NULL_LENGTH)
331
 
      {            /* null field */
332
 
        cur->data[field] = 0;
333
 
      }
334
 
      else
335
 
      {
336
 
        cur->data[field] = to;
337
 
        if (len > (uint32_t) (end_to - to))
338
 
        {
339
 
          free_rows(result);
340
 
          drizzle_set_error(drizzle, CR_MALFORMED_PACKET,
341
 
                            sqlstate_get_unknown());
342
 
          return(0);
343
 
        }
344
 
        memcpy(to, cp, len);
345
 
        to[len]=0;
346
 
        to+=len+1;
347
 
        cp+=len;
348
 
        if (DRIZZLE_FIELDs)
349
 
        {
350
 
          if (DRIZZLE_FIELDs[field].max_length < len)
351
 
            DRIZZLE_FIELDs[field].max_length=len;
352
 
        }
353
 
      }
354
 
    }
355
 
    cur->data[field]=to;      /* End of last field */
356
 
    if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
357
 
    {
358
 
      free_rows(result);
359
 
      return(0);
360
 
    }
361
 
  }
362
 
  *prev_ptr=0;          /* last pointer is null */
363
 
  if (pkt_len > 1)        /* DRIZZLE 4.1 protocol */
364
 
  {
365
 
    drizzle->warning_count= uint2korr(cp+1);
366
 
    drizzle->server_status= uint2korr(cp+3);
367
 
  }
368
 
  return(result);
369
 
}
370
 
 
371
 
/*
372
 
  Read one row. Uses packet buffer as storage for fields.
373
 
  When next packet is read, the previous field values are destroyed
374
 
*/
375
 
 
376
 
 
377
 
static int32_t
378
 
read_one_row(DRIZZLE *drizzle, uint32_t fields, DRIZZLE_ROW row, uint32_t *lengths)
379
 
{
380
 
  uint32_t field;
381
 
  uint32_t pkt_len,len;
382
 
  unsigned char *pos, *prev_pos, *end_pos;
383
 
  NET *net= &drizzle->net;
384
 
 
385
 
  if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
386
 
    return -1;
387
 
  if (pkt_len <= 8 && net->read_pos[0] == DRIZZLE_PROTOCOL_NO_MORE_DATA)
388
 
  {
389
 
    if (pkt_len > 1)        /* DRIZZLE 4.1 protocol */
390
 
    {
391
 
      drizzle->warning_count= uint2korr(net->read_pos+1);
392
 
      drizzle->server_status= uint2korr(net->read_pos+3);
393
 
    }
394
 
    return 1;        /* End of data */
395
 
  }
396
 
  prev_pos= 0;        /* allowed to write at packet[-1] */
397
 
  pos=net->read_pos;
398
 
  end_pos=pos+pkt_len;
399
 
  for (field=0 ; field < fields ; field++)
400
 
  {
401
 
    if ((len= net_field_length(&pos)) == NULL_LENGTH)
402
 
    {            /* null field */
403
 
      row[field] = 0;
404
 
      *lengths++=0;
405
 
    }
406
 
    else
407
 
    {
408
 
      if (len > (uint32_t) (end_pos - pos))
409
 
      {
410
 
        drizzle_set_error(drizzle, CR_UNKNOWN_ERROR,
411
 
                          sqlstate_get_unknown());
412
 
        return -1;
413
 
      }
414
 
      row[field] = (char*) pos;
415
 
      pos+=len;
416
 
      *lengths++=len;
417
 
    }
418
 
    if (prev_pos)
419
 
      *prev_pos=0;        /* Terminate prev field */
420
 
    prev_pos=pos;
421
 
  }
422
 
  row[field]=(char*) prev_pos+1;    /* End of last field */
423
 
  *prev_pos=0;          /* Terminate last field */
424
 
  return 0;
425
 
}
426
 
 
427
 
 
428
 
/**************************************************************************
429
 
  Return next row of the query results
430
 
**************************************************************************/
431
 
 
432
 
DRIZZLE_ROW
433
 
drizzle_fetch_row(DRIZZLE_RES *res)
434
 
{
435
 
  if (!res->data)
436
 
  {            /* Unbufferred fetch */
437
 
    if (!res->eof)
438
 
    {
439
 
      DRIZZLE *drizzle= res->handle;
440
 
      if (drizzle->status != DRIZZLE_STATUS_USE_RESULT)
441
 
      {
442
 
        drizzle_set_error(drizzle,
443
 
                          res->unbuffered_fetch_cancelled ?
444
 
                          CR_FETCH_CANCELED : CR_COMMANDS_OUT_OF_SYNC,
445
 
                          sqlstate_get_unknown());
446
 
      }
447
 
      else if (!(read_one_row(drizzle, res->field_count, res->row, res->lengths)))
448
 
      {
449
 
  res->row_count++;
450
 
  return(res->current_row=res->row);
451
 
      }
452
 
      res->eof=1;
453
 
      drizzle->status=DRIZZLE_STATUS_READY;
454
 
      /*
455
 
        Reset only if owner points to us: there is a chance that somebody
456
 
        started new query after drizzle_stmt_close():
457
 
      */
458
 
      if (drizzle->unbuffered_fetch_owner == &res->unbuffered_fetch_cancelled)
459
 
        drizzle->unbuffered_fetch_owner= 0;
460
 
      /* Don't clear handle in drizzle_free_result */
461
 
      res->handle=0;
462
 
    }
463
 
    return((DRIZZLE_ROW) NULL);
464
 
  }
465
 
  {
466
 
    DRIZZLE_ROW tmp;
467
 
    if (!res->data_cursor)
468
 
    {
469
 
      return(res->current_row=(DRIZZLE_ROW) NULL);
470
 
    }
471
 
    tmp = res->data_cursor->data;
472
 
    res->data_cursor = res->data_cursor->next;
473
 
    return(res->current_row=tmp);
474
 
  }
475
 
}
476
 
 
477
 
 
478
 
/**************************************************************************
479
 
  Get column lengths of the current row
480
 
  If one uses drizzle_use_result, res->lengths contains the length information,
481
 
  else the lengths are calculated from the offset between pointers.
482
 
**************************************************************************/
483
 
 
484
 
uint32_t *
485
 
drizzle_fetch_lengths(DRIZZLE_RES *res)
486
 
{
487
 
  DRIZZLE_ROW column;
488
 
 
489
 
  if (!(column=res->current_row))
490
 
    return 0;          /* Something is wrong */
491
 
  if (res->data)
492
 
    (*res->methods->fetch_lengths)(res->lengths, column, res->field_count);
493
 
  return res->lengths;
494
 
}
495
 
 
496
 
 
497
 
int
498
 
drizzle_options(DRIZZLE *drizzle,enum drizzle_option option, const void *arg)
499
 
{
500
 
  switch (option) {
501
 
  case DRIZZLE_OPT_CONNECT_TIMEOUT:
502
 
    drizzle->options.connect_timeout= *(uint32_t*) arg;
503
 
    break;
504
 
  case DRIZZLE_OPT_READ_TIMEOUT:
505
 
    drizzle->options.read_timeout= *(uint32_t*) arg;
506
 
    break;
507
 
  case DRIZZLE_OPT_WRITE_TIMEOUT:
508
 
    drizzle->options.write_timeout= *(uint32_t*) arg;
509
 
    break;
510
 
  case DRIZZLE_OPT_COMPRESS:
511
 
    drizzle->options.compress= 1;      /* Remember for connect */
512
 
    drizzle->options.client_flag|= CLIENT_COMPRESS;
513
 
    break;
514
 
  case DRIZZLE_OPT_LOCAL_INFILE:      /* Allow LOAD DATA LOCAL ?*/
515
 
    if (!arg || (*(uint32_t*) arg) ? 1 : 0)
516
 
      drizzle->options.client_flag|= CLIENT_LOCAL_FILES;
517
 
    else
518
 
      drizzle->options.client_flag&= ~CLIENT_LOCAL_FILES;
519
 
    break;
520
 
  case DRIZZLE_READ_DEFAULT_FILE:
521
 
    if (drizzle->options.my_cnf_file != NULL)
522
 
      free(drizzle->options.my_cnf_file);
523
 
    drizzle->options.my_cnf_file=strdup(arg);
524
 
    break;
525
 
  case DRIZZLE_READ_DEFAULT_GROUP:
526
 
    if (drizzle->options.my_cnf_group != NULL)
527
 
      free(drizzle->options.my_cnf_group);
528
 
    drizzle->options.my_cnf_group=strdup(arg);
529
 
    break;
530
 
  case DRIZZLE_OPT_PROTOCOL:
531
 
    break;
532
 
  case DRIZZLE_OPT_USE_REMOTE_CONNECTION:
533
 
  case DRIZZLE_OPT_GUESS_CONNECTION:
534
 
    drizzle->options.methods_to_use= option;
535
 
    break;
536
 
  case DRIZZLE_SET_CLIENT_IP:
537
 
    drizzle->options.client_ip= strdup(arg);
538
 
    break;
539
 
  case DRIZZLE_SECURE_AUTH:
540
 
    drizzle->options.secure_auth= *(const bool *) arg;
541
 
    break;
542
 
  case DRIZZLE_REPORT_DATA_TRUNCATION:
543
 
    drizzle->options.report_data_truncation= (*(const bool *) arg) ? 1 : 0;
544
 
    break;
545
 
  case DRIZZLE_OPT_RECONNECT:
546
 
    drizzle->reconnect= *(const bool *) arg;
547
 
    break;
548
 
  case DRIZZLE_OPT_SSL_VERIFY_SERVER_CERT:
549
 
    if (*(const bool*) arg)
550
 
      drizzle->options.client_flag|= CLIENT_SSL_VERIFY_SERVER_CERT;
551
 
    else
552
 
      drizzle->options.client_flag&= ~CLIENT_SSL_VERIFY_SERVER_CERT;
553
 
    break;
554
 
  default:
555
 
    return(1);
556
 
  }
557
 
  return(0);
558
 
}
559
 
 
560
 
 
561
 
/****************************************************************************
562
 
  Functions to get information from the DRIZZLE structure
563
 
  These are functions to make shared libraries more usable.
564
 
****************************************************************************/
565
 
 
566
 
/* DRIZZLE_RES */
567
 
uint64_t drizzle_num_rows(const DRIZZLE_RES *res)
568
 
{
569
 
  return res->row_count;
570
 
}
571
 
 
572
 
unsigned int drizzle_num_fields(const DRIZZLE_RES *res)
573
 
{
574
 
  return res->field_count;
575
 
}
576
 
 
577
 
 
578
 
/*
579
 
  Get version number for server in a form easy to test on
580
 
 
581
 
  SYNOPSIS
582
 
    drizzle_get_server_version()
583
 
    drizzle Connection
584
 
 
585
 
  EXAMPLE
586
 
    4.1.0-alfa ->  40100
587
 
 
588
 
  NOTES
589
 
    We will ensure that a newer server always has a bigger number.
590
 
 
591
 
  RETURN
592
 
   Signed number > 323000
593
 
*/
594
 
 
595
 
uint32_t
596
 
drizzle_get_server_version(const DRIZZLE *drizzle)
597
 
{
598
 
  uint32_t major, minor, version;
599
 
  char *pos= drizzle->server_version, *end_pos;
600
 
  major=   (uint32_t) strtoul(pos, &end_pos, 10);  pos=end_pos+1;
601
 
  minor=   (uint32_t) strtoul(pos, &end_pos, 10);  pos=end_pos+1;
602
 
  version= (uint32_t) strtoul(pos, &end_pos, 10);
603
 
  return (uint32_t) major*10000L+(uint32_t) (minor*100+version);
604
 
}
605