« back to all changes in this revision
Viewing changes to libdrizzle/client.c
- browse files at revision 212
- compare with another revision
- compare with revision 1086.10.2
- download diff
- download tarball
- view history from revision 212
- Committer: Brian Aker
- Date: 2008-07-26 04:51:46 UTC
- mfrom: (202.1.25 codestyle)
- Revision ID: brian@tangent.org-20080726045146-ax7ofn8aqnkycjl3
Merge from Monty
- files renamed:
- extra/comp_err.c => include/comp_err.c
- files modified:
- Makefile.am
added
removed
libdrizzle/client.c
1
/* Copyright (C) 2000-2003 MySQL AB
1
/* Copyright (C) 2008 Drizzle Open Source Project
2
2
3
3
This program is free software; you can redistribute it and/or modify
4
4
it under the terms of the GNU General Public License as published by
14
14
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
15
15
16
16
/*
17
This file is included by both libmysql.c (the MySQL client C API)
18
and the mysqld server to connect to another MYSQL server.
17
This file is included by both libdrizzle.c (the DRIZZLE client C API)
18
and the drizzled server to connect to another DRIZZLE server.
19
19
20
20
The differences for the two cases are:
21
21
22
22
- Things that only works for the client:
23
23
- Trying to automaticly determinate user name if not supplied to
24
mysql_real_connect()
24
drizzle_connect()
25
25
- Support for reading local file with LOAD DATA LOCAL
26
26
- SHARED memory handling
27
27
- Protection against sigpipe
28
28
- Prepared statements
29
29
30
30
- Things that only works for the server
31
31
- Alarm handling on connect
32
32
33
33
In all other cases, the code should be idential for the client and
34
34
server.
35
*/
35
*/
36
36
37
37
#include <my_global.h>
38
38
44
44
#undef max_allowed_packet
45
45
#undef net_buffer_length
46
46
47
#define CLI_MYSQL_REAL_CONNECT STDCALL mysql_real_connect
47
#define CLI_DRIZZLE_CONNECT STDCALL drizzle_connect
48
48
49
49
#include <my_sys.h>
50
50
#include <mysys_err.h>
54
54
#include "mysqld_error.h"
55
55
#include "errmsg.h"
56
56
#include <violite.h>
57
#include <my_pthread.h> /* because of signal() */
57
#include <my_pthread.h> /* because of signal() */
58
58
59
59
#include <sys/stat.h>
60
60
#include <signal.h>
61
61
#include <time.h>
62
#ifdef HAVE_PWD_H
62
#ifdef HAVE_PWD_H
63
63
#include <pwd.h>
64
64
#endif
65
65
84
84
#include "client_settings.h"
85
85
#include <sql_common.h>
86
86
87
uint mysql_port=0;
88
char *mysql_unix_port= 0;
89
const char *unknown_sqlstate= "HY000";
90
const char *not_error_sqlstate= "00000";
91
const char *cant_connect_sqlstate= "08001";
92
93
static void mysql_close_free_options(MYSQL *mysql);
94
static void mysql_close_free(MYSQL *mysql);
87
uint drizzle_port=0;
88
char *drizzle_unix_port= 0;
89
const char *unknown_sqlstate= "HY000";
90
const char *not_error_sqlstate= "00000";
91
const char *cant_connect_sqlstate= "08001";
92
93
static bool drizzle_client_init= false;
94
static bool org_my_init_done= false;
95
96
static void drizzle_close_free_options(DRIZZLE *drizzle);
97
static void drizzle_close_free(DRIZZLE *drizzle);
95
98
96
99
static int wait_for_data(my_socket fd, uint timeout);
97
100
98
101
CHARSET_INFO *default_client_charset_info = &my_charset_latin1;
99
102
100
103
/* Server error code and message */
101
unsigned int mysql_server_last_errno;
102
char mysql_server_last_error[MYSQL_ERRMSG_SIZE];
104
unsigned int drizzle_server_last_errno;
105
char drizzle_server_last_error[MYSQL_ERRMSG_SIZE];
103
106
104
107
/****************************************************************************
105
108
A modified version of connect(). my_connect() allows you to specify
111
114
*****************************************************************************/
112
115
113
116
int my_connect(my_socket fd, const struct sockaddr *name, uint namelen,
114
uint timeout)
117
uint timeout)
115
118
{
116
119
int flags, res, s_err;
117
120
123
126
if (timeout == 0)
124
127
return connect(fd, (struct sockaddr*) name, namelen);
125
128
126
flags = fcntl(fd, F_GETFL, 0); /* Set socket to not block */
129
flags = fcntl(fd, F_GETFL, 0); /* Set socket to not block */
127
130
#ifdef O_NONBLOCK
128
131
fcntl(fd, F_SETFL, flags | O_NONBLOCK); /* and save the flags.. */
129
132
#endif
130
133
131
134
res= connect(fd, (struct sockaddr*) name, namelen);
132
s_err= errno; /* Save the error... */
135
s_err= errno; /* Save the error... */
133
136
fcntl(fd, F_SETFL, flags);
134
137
if ((res != 0) && (s_err != EINPROGRESS))
135
138
{
136
errno= s_err; /* Restore it */
139
errno= s_err; /* Restore it */
137
140
return(-1);
138
141
}
139
if (res == 0) /* Connected quickly! */
142
if (res == 0) /* Connected quickly! */
140
143
return(0);
141
144
return wait_for_data(fd, timeout);
142
145
}
172
175
time_t start_time, now_time;
173
176
int res, s_err;
174
177
175
if (fd >= FD_SETSIZE) /* Check if wrong error */
176
return 0; /* Can't use timeout */
178
if (fd >= FD_SETSIZE) /* Check if wrong error */
179
return 0; /* Can't use timeout */
177
180
178
181
/*
179
182
Our connection is "in progress." We can use the select() call to wait
181
184
If select() returns 0 (after waiting howevermany seconds), our socket
182
185
never became writable (host is probably unreachable.) Otherwise, if
183
186
select() returns 1, then one of two conditions exist:
184
187
185
188
1. An error occured. We use getsockopt() to check for this.
186
189
2. The connection was set up sucessfully: getsockopt() will
187
190
return 0 as an error.
188
191
189
192
Thanks goes to Andrew Gierth <andrew@erlenstar.demon.co.uk>
190
193
who posted this method of timing out a connect() in
191
194
comp.unix.programmer on August 15th, 1997.
194
197
FD_ZERO(&sfds);
195
198
FD_SET(fd, &sfds);
196
199
/*
197
select could be interrupted by a signal, and if it is,
200
select could be interrupted by a signal, and if it is,
198
201
the timeout should be adjusted and the select restarted
199
to work around OSes that don't restart select and
202
to work around OSes that don't restart select and
200
203
implementations of select that don't adjust tv upon
201
204
failure to reflect the time remaining
202
205
*/
212
215
if ((res = select(fd+1, NULL, &sfds, NULL, &tv)) > 0)
213
216
break;
214
217
#endif
215
if (res == 0) /* timeout */
218
if (res == 0) /* timeout */
216
219
return -1;
217
220
now_time= my_time(0);
218
221
timeout-= (uint) (now_time - start_time);
231
234
return(-1);
232
235
233
236
if (s_err)
234
{ /* getsockopt could succeed */
237
{ /* getsockopt could succeed */
235
238
errno = s_err;
236
return(-1); /* but return an error... */
239
return(-1); /* but return an error... */
237
240
}
238
return (0); /* ok */
241
return (0); /* ok */
239
242
#endif /* HAVE_POLL */
240
243
}
241
244
242
245
/**
243
Set the internal error message to mysql handler
246
Set the internal error message to DRIZZLE handler
244
247
245
@param mysql connection handle (client side)
248
@param drizzle connection handle (client side)
246
249
@param errcode CR_ error code, passed to ER macro to get
247
250
error text
248
251
@parma sqlstate SQL standard sqlstate
249
252
*/
250
253
251
void set_mysql_error(MYSQL *mysql, int errcode, const char *sqlstate)
254
void set_drizzle_error(DRIZZLE *drizzle, int errcode, const char *sqlstate)
252
255
{
253
256
NET *net;
254
assert(mysql != 0);
257
assert(drizzle != 0);
255
258
256
if (mysql)
259
if (drizzle)
257
260
{
258
net= &mysql->net;
261
net= &drizzle->net;
259
262
net->last_errno= errcode;
260
263
strmov(net->last_error, ER(errcode));
261
264
strmov(net->sqlstate, sqlstate);
262
265
}
263
266
else
264
267
{
265
mysql_server_last_errno= errcode;
266
strmov(mysql_server_last_error, ER(errcode));
268
drizzle_server_last_errno= errcode;
269
strmov(drizzle_server_last_error, ER(errcode));
267
270
}
268
271
return;
269
272
}
284
287
/**
285
288
Set an error message on the client.
286
289
287
@param mysql connection handle
290
@param drizzle connection handle
288
291
@param errcode CR_* errcode, for client errors
289
292
@param sqlstate SQL standard sql state, unknown_sqlstate for the
290
293
majority of client errors.
292
295
@param ... variable number of arguments
293
296
*/
294
297
295
static void set_mysql_extended_error(MYSQL *mysql, int errcode,
298
static void set_drizzle_extended_error(DRIZZLE *drizzle, int errcode,
296
299
const char *sqlstate,
297
300
const char *format, ...)
298
301
{
299
302
NET *net;
300
303
va_list args;
301
assert(mysql != 0);
304
assert(drizzle != 0);
302
305
303
net= &mysql->net;
306
net= &drizzle->net;
304
307
net->last_errno= errcode;
305
308
va_start(args, format);
306
309
vsnprintf(net->last_error, sizeof(net->last_error)-1,
316
319
or packet is an error message
317
320
*****************************************************************************/
318
321
319
uint32_t cli_safe_read(MYSQL *mysql)
322
uint32_t cli_safe_read(DRIZZLE *drizzle)
320
323
{
321
NET *net= &mysql->net;
324
NET *net= &drizzle->net;
322
325
ulong len=0;
323
326
init_sigpipe_variables
324
327
325
328
/* Don't give sigpipe errors if the client doesn't want them */
326
set_sigpipe(mysql);
329
set_sigpipe(drizzle);
327
330
if (net->vio != 0)
328
331
len=my_net_read(net);
329
reset_sigpipe(mysql);
332
reset_sigpipe(drizzle);
330
333
331
334
if (len == packet_error || len == 0)
332
335
{
333
336
#ifdef MYSQL_SERVER
334
337
if (net->vio && vio_was_interrupted(net->vio))
335
338
return (packet_error);
336
#endif /*MYSQL_SERVER*/
337
end_server(mysql);
338
set_mysql_error(mysql, net->last_errno == ER_NET_PACKET_TOO_LARGE ?
339
#endif /*DRIZZLE_SERVER*/
340
end_server(drizzle);
341
set_drizzle_error(drizzle, net->last_errno == ER_NET_PACKET_TOO_LARGE ?
339
342
CR_NET_PACKET_TOO_LARGE: CR_SERVER_LOST, unknown_sqlstate);
340
343
return (packet_error);
341
344
}
347
350
net->last_errno=uint2korr(pos);
348
351
pos+=2;
349
352
len-=2;
350
if (protocol_41(mysql) && pos[0] == '#')
353
if (protocol_41(drizzle) && pos[0] == '#')
351
354
{
352
strmake(net->sqlstate, pos+1, SQLSTATE_LENGTH);
353
pos+= SQLSTATE_LENGTH+1;
355
strmake(net->sqlstate, pos+1, SQLSTATE_LENGTH);
356
pos+= SQLSTATE_LENGTH+1;
354
357
}
355
358
else
356
359
{
363
366
}
364
367
365
368
(void) strmake(net->last_error,(char*) pos,
366
min((uint) len,(uint) sizeof(net->last_error)-1));
369
min((uint) len,(uint) sizeof(net->last_error)-1));
367
370
}
368
371
else
369
set_mysql_error(mysql, CR_UNKNOWN_ERROR, unknown_sqlstate);
372
set_drizzle_error(drizzle, CR_UNKNOWN_ERROR, unknown_sqlstate);
370
373
/*
371
374
Cover a protocol design error: error packet does not
372
375
contain the server status. Therefore, the client has no way
376
379
a multi-statement or a stored procedure, so it should be
377
380
safe to unconditionally turn off the flag here.
378
381
*/
379
mysql->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
382
drizzle->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
380
383
381
384
return(packet_error);
382
385
}
383
386
return len;
384
387
}
385
388
386
void free_rows(MYSQL_DATA *cur)
389
void free_rows(DRIZZLE_DATA *cur)
387
390
{
388
391
if (cur)
389
392
{
393
396
}
394
397
395
398
bool
396
cli_advanced_command(MYSQL *mysql, enum enum_server_command command,
397
const unsigned char *header, uint32_t header_length,
398
const unsigned char *arg, uint32_t arg_length, bool skip_check)
399
cli_advanced_command(DRIZZLE *drizzle, enum enum_server_command command,
400
const unsigned char *header, uint32_t header_length,
401
const unsigned char *arg, uint32_t arg_length, bool skip_check)
399
402
{
400
NET *net= &mysql->net;
403
NET *net= &drizzle->net;
401
404
my_bool result= 1;
402
405
init_sigpipe_variables
403
406
my_bool stmt_skip= false;
404
407
405
408
/* Don't give sigpipe errors if the client doesn't want them */
406
set_sigpipe(mysql);
409
set_sigpipe(drizzle);
407
410
408
if (mysql->net.vio == 0)
409
{ /* Do reconnect if possible */
410
if (mysql_reconnect(mysql) || stmt_skip)
411
if (drizzle->net.vio == 0)
412
{ /* Do reconnect if possible */
413
if (drizzle_reconnect(drizzle) || stmt_skip)
411
414
return(1);
412
415
}
413
if (mysql->status != MYSQL_STATUS_READY ||
414
mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
416
if (drizzle->status != DRIZZLE_STATUS_READY ||
417
drizzle->server_status & SERVER_MORE_RESULTS_EXISTS)
415
418
{
416
set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
419
set_drizzle_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
417
420
return(1);
418
421
}
419
422
420
423
net_clear_error(net);
421
mysql->info=0;
422
mysql->affected_rows= ~(uint64_t) 0;
424
drizzle->info=0;
425
drizzle->affected_rows= ~(uint64_t) 0;
423
426
/*
424
427
We don't want to clear the protocol buffer on COM_QUIT, because if
425
428
the previous command was a shutdown command, we may have the
426
429
response for the COM_QUIT already in the communication buffer
427
430
*/
428
net_clear(&mysql->net, (command != COM_QUIT));
431
net_clear(&drizzle->net, (command != COM_QUIT));
429
432
430
433
if (net_write_command(net,(uchar) command, header, header_length,
431
arg, arg_length))
434
arg, arg_length))
432
435
{
433
436
if (net->last_errno == ER_NET_PACKET_TOO_LARGE)
434
437
{
435
set_mysql_error(mysql, CR_NET_PACKET_TOO_LARGE, unknown_sqlstate);
438
set_drizzle_error(drizzle, CR_NET_PACKET_TOO_LARGE, unknown_sqlstate);
436
439
goto end;
437
440
}
438
end_server(mysql);
439
if (mysql_reconnect(mysql) || stmt_skip)
441
end_server(drizzle);
442
if (drizzle_reconnect(drizzle) || stmt_skip)
440
443
goto end;
441
444
if (net_write_command(net,(uchar) command, header, header_length,
442
arg, arg_length))
445
arg, arg_length))
443
446
{
444
set_mysql_error(mysql, CR_SERVER_GONE_ERROR, unknown_sqlstate);
447
set_drizzle_error(drizzle, CR_SERVER_GONE_ERROR, unknown_sqlstate);
445
448
goto end;
446
449
}
447
450
}
448
451
result=0;
449
452
if (!skip_check)
450
result= ((mysql->packet_length=cli_safe_read(mysql)) == packet_error ?
451
1 : 0);
453
result= ((drizzle->packet_length=cli_safe_read(drizzle)) == packet_error ?
454
1 : 0);
452
455
end:
453
reset_sigpipe(mysql);
456
reset_sigpipe(drizzle);
454
457
return(result);
455
458
}
456
459
457
void free_old_query(MYSQL *mysql)
460
void free_old_query(DRIZZLE *drizzle)
458
461
{
459
if (mysql->fields)
460
free_root(&mysql->field_alloc,MYF(0));
461
init_alloc_root(&mysql->field_alloc,8192,0); /* Assume rowlength < 8192 */
462
mysql->fields= 0;
463
mysql->field_count= 0; /* For API */
464
mysql->warning_count= 0;
465
mysql->info= 0;
462
if (drizzle->fields)
463
free_root(&drizzle->field_alloc,MYF(0));
464
init_alloc_root(&drizzle->field_alloc,8192,0); /* Assume rowlength < 8192 */
465
drizzle->fields= 0;
466
drizzle->field_count= 0; /* For API */
467
drizzle->warning_count= 0;
468
drizzle->info= 0;
466
469
return;
467
470
}
468
471
470
473
Flush result set sent from server
471
474
*/
472
475
473
static void cli_flush_use_result(MYSQL *mysql)
476
static void cli_flush_use_result(DRIZZLE *drizzle)
474
477
{
475
478
/* Clear the current execution status */
476
479
for (;;)
477
480
{
478
481
ulong pkt_len;
479
if ((pkt_len=cli_safe_read(mysql)) == packet_error)
482
if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
480
483
break;
481
if (pkt_len <= 8 && mysql->net.read_pos[0] == 254)
484
if (pkt_len <= 8 && drizzle->net.read_pos[0] == 254)
482
485
{
483
if (protocol_41(mysql))
486
if (protocol_41(drizzle))
484
487
{
485
char *pos= (char*) mysql->net.read_pos + 1;
486
mysql->warning_count=uint2korr(pos); pos+=2;
487
mysql->server_status=uint2korr(pos); pos+=2;
488
char *pos= (char*) drizzle->net.read_pos + 1;
489
drizzle->warning_count=uint2korr(pos); pos+=2;
490
drizzle->server_status=uint2korr(pos); pos+=2;
488
491
}
489
492
break; /* End of data */
490
493
}
497
500
Shut down connection
498
501
**************************************************************************/
499
502
500
void end_server(MYSQL *mysql)
503
void end_server(DRIZZLE *drizzle)
501
504
{
502
505
int save_errno= errno;
503
if (mysql->net.vio != 0)
506
if (drizzle->net.vio != 0)
504
507
{
505
508
init_sigpipe_variables
506
set_sigpipe(mysql);
507
vio_delete(mysql->net.vio);
508
reset_sigpipe(mysql);
509
mysql->net.vio= 0; /* Marker */
509
set_sigpipe(drizzle);
510
vio_delete(drizzle->net.vio);
511
reset_sigpipe(drizzle);
512
drizzle->net.vio= 0; /* Marker */
510
513
}
511
net_end(&mysql->net);
512
free_old_query(mysql);
514
net_end(&drizzle->net);
515
free_old_query(drizzle);
513
516
errno= save_errno;
514
517
return;
515
518
}
516
519
517
520
518
521
void STDCALL
519
mysql_free_result(MYSQL_RES *result)
522
drizzle_free_result(DRIZZLE_RES *result)
520
523
{
521
524
if (result)
522
525
{
523
MYSQL *mysql= result->handle;
524
if (mysql)
526
DRIZZLE *drizzle= result->handle;
527
if (drizzle)
525
528
{
526
if (mysql->unbuffered_fetch_owner == &result->unbuffered_fetch_cancelled)
527
mysql->unbuffered_fetch_owner= 0;
528
if (mysql->status == MYSQL_STATUS_USE_RESULT)
529
if (drizzle->unbuffered_fetch_owner == &result->unbuffered_fetch_cancelled)
530
drizzle->unbuffered_fetch_owner= 0;
531
if (drizzle->status == DRIZZLE_STATUS_USE_RESULT)
529
532
{
530
(*mysql->methods->flush_use_result)(mysql);
531
mysql->status=MYSQL_STATUS_READY;
532
if (mysql->unbuffered_fetch_owner)
533
*mysql->unbuffered_fetch_owner= true;
533
(*drizzle->methods->flush_use_result)(drizzle);
534
drizzle->status=DRIZZLE_STATUS_READY;
535
if (drizzle->unbuffered_fetch_owner)
536
*drizzle->unbuffered_fetch_owner= true;
534
537
}
535
538
}
536
539
free_rows(result->data);
561
564
};
562
565
563
566
static TYPELIB option_types={array_elements(default_options)-1,
564
"options",default_options, NULL};
567
"options",default_options, NULL};
565
568
566
569
const char *sql_protocol_names_lib[] =
567
570
{ "TCP", "SOCKET", "PIPE", "MEMORY", NullS };
568
571
TYPELIB sql_protocol_typelib = {array_elements(sql_protocol_names_lib)-1,"",
569
sql_protocol_names_lib, NULL};
572
sql_protocol_names_lib, NULL};
570
573
571
static int add_init_command(struct st_mysql_options *options, const char *cmd)
574
static int add_init_command(struct st_drizzle_options *options, const char *cmd)
572
575
{
573
576
char *tmp;
574
577
575
578
if (!options->init_commands)
576
579
{
577
580
options->init_commands= (DYNAMIC_ARRAY*)my_malloc(sizeof(DYNAMIC_ARRAY),
578
MYF(MY_WME));
581
MYF(MY_WME));
579
582
init_dynamic_array(options->init_commands,sizeof(char*),0,5 CALLER_INFO);
580
583
}
581
584
589
592
return 0;
590
593
}
591
594
592
void mysql_read_default_options(struct st_mysql_options *options,
593
const char *filename,const char *group)
595
void drizzle_read_default_options(struct st_drizzle_options *options,
596
const char *filename,const char *group)
594
597
{
595
598
int argc;
596
599
char *argv_buff[1],**argv;
600
603
groups[0]= (char*) "client"; groups[1]= (char*) group; groups[2]=0;
601
604
602
605
load_defaults(filename, groups, &argc, &argv);
603
if (argc != 1) /* If some default option */
606
if (argc != 1) /* If some default option */
604
607
{
605
608
char **option=argv;
606
609
while (*++option)
607
610
{
608
611
if (option[0][0] == '-' && option[0][1] == '-')
609
612
{
610
char *end=strcend(*option,'=');
611
char *opt_arg=0;
612
if (*end)
613
{
614
opt_arg=end+1;
615
*end=0; /* Remove '=' */
616
}
617
/* Change all '_' in variable name to '-' */
618
for (end= *option ; *(end= strcend(end,'_')) ; )
619
*end= '-';
620
switch (find_type(*option+2,&option_types,2)) {
621
case 1: /* port */
622
if (opt_arg)
623
options->port=atoi(opt_arg);
624
break;
625
case 2: /* socket */
626
if (opt_arg)
627
{
628
my_free(options->unix_socket,MYF(MY_ALLOW_ZERO_PTR));
629
options->unix_socket=my_strdup(opt_arg,MYF(MY_WME));
630
}
631
break;
632
case 3: /* compress */
633
options->compress=1;
634
options->client_flag|= CLIENT_COMPRESS;
635
break;
636
case 4: /* password */
637
if (opt_arg)
638
{
639
my_free(options->password,MYF(MY_ALLOW_ZERO_PTR));
640
options->password=my_strdup(opt_arg,MYF(MY_WME));
641
}
642
break;
613
char *end=strcend(*option,'=');
614
char *opt_arg=0;
615
if (*end)
616
{
617
opt_arg=end+1;
618
*end=0; /* Remove '=' */
619
}
620
/* Change all '_' in variable name to '-' */
621
for (end= *option ; *(end= strcend(end,'_')) ; )
622
*end= '-';
623
switch (find_type(*option+2,&option_types,2)) {
624
case 1: /* port */
625
if (opt_arg)
626
options->port=atoi(opt_arg);
627
break;
628
case 2: /* socket */
629
if (opt_arg)
630
{
631
my_free(options->unix_socket,MYF(MY_ALLOW_ZERO_PTR));
632
options->unix_socket=my_strdup(opt_arg,MYF(MY_WME));
633
}
634
break;
635
case 3: /* compress */
636
options->compress=1;
637
options->client_flag|= CLIENT_COMPRESS;
638
break;
639
case 4: /* password */
640
if (opt_arg)
641
{
642
my_free(options->password,MYF(MY_ALLOW_ZERO_PTR));
643
options->password=my_strdup(opt_arg,MYF(MY_WME));
644
}
645
break;
643
646
case 5:
644
options->protocol = MYSQL_PROTOCOL_PIPE;
645
case 20: /* connect_timeout */
646
case 6: /* timeout */
647
if (opt_arg)
648
options->connect_timeout=atoi(opt_arg);
649
break;
650
case 7: /* user */
651
if (opt_arg)
652
{
653
my_free(options->user,MYF(MY_ALLOW_ZERO_PTR));
654
options->user=my_strdup(opt_arg,MYF(MY_WME));
655
}
656
break;
657
case 8: /* init-command */
658
add_init_command(options,opt_arg);
659
break;
660
case 9: /* host */
661
if (opt_arg)
662
{
663
my_free(options->host,MYF(MY_ALLOW_ZERO_PTR));
664
options->host=my_strdup(opt_arg,MYF(MY_WME));
665
}
666
break;
667
case 10: /* database */
668
if (opt_arg)
669
{
670
my_free(options->db,MYF(MY_ALLOW_ZERO_PTR));
671
options->db=my_strdup(opt_arg,MYF(MY_WME));
672
}
673
break;
674
case 12: /* return-found-rows */
675
options->client_flag|=CLIENT_FOUND_ROWS;
676
break;
677
case 13: /* Ignore SSL options */
678
case 14:
679
case 15:
680
case 16:
647
options->protocol = DRIZZLE_PROTOCOL_PIPE;
648
case 20: /* connect_timeout */
649
case 6: /* timeout */
650
if (opt_arg)
651
options->connect_timeout=atoi(opt_arg);
652
break;
653
case 7: /* user */
654
if (opt_arg)
655
{
656
my_free(options->user,MYF(MY_ALLOW_ZERO_PTR));
657
options->user=my_strdup(opt_arg,MYF(MY_WME));
658
}
659
break;
660
case 8: /* init-command */
661
add_init_command(options,opt_arg);
662
break;
663
case 9: /* host */
664
if (opt_arg)
665
{
666
my_free(options->host,MYF(MY_ALLOW_ZERO_PTR));
667
options->host=my_strdup(opt_arg,MYF(MY_WME));
668
}
669
break;
670
case 10: /* database */
671
if (opt_arg)
672
{
673
my_free(options->db,MYF(MY_ALLOW_ZERO_PTR));
674
options->db=my_strdup(opt_arg,MYF(MY_WME));
675
}
676
break;
677
case 12: /* return-found-rows */
678
options->client_flag|=CLIENT_FOUND_ROWS;
679
break;
680
case 13: /* Ignore SSL options */
681
case 14:
682
case 15:
683
case 16:
681
684
case 23:
682
break;
683
case 17: /* charset-lib */
684
my_free(options->charset_dir,MYF(MY_ALLOW_ZERO_PTR));
685
break;
686
case 17: /* charset-lib */
687
my_free(options->charset_dir,MYF(MY_ALLOW_ZERO_PTR));
685
688
options->charset_dir = my_strdup(opt_arg, MYF(MY_WME));
686
break;
687
case 18:
688
my_free(options->charset_name,MYF(MY_ALLOW_ZERO_PTR));
689
break;
690
case 18:
691
my_free(options->charset_name,MYF(MY_ALLOW_ZERO_PTR));
689
692
options->charset_name = my_strdup(opt_arg, MYF(MY_WME));
690
break;
691
case 19: /* Interactive-timeout */
692
options->client_flag|= CLIENT_INTERACTIVE;
693
break;
694
case 21:
695
if (!opt_arg || atoi(opt_arg) != 0)
696
options->client_flag|= CLIENT_LOCAL_FILES;
697
else
698
options->client_flag&= ~CLIENT_LOCAL_FILES;
699
break;
700
case 22:
701
options->client_flag&= ~CLIENT_LOCAL_FILES;
693
break;
694
case 19: /* Interactive-timeout */
695
options->client_flag|= CLIENT_INTERACTIVE;
696
break;
697
case 21:
698
if (!opt_arg || atoi(opt_arg) != 0)
699
options->client_flag|= CLIENT_LOCAL_FILES;
700
else
701
options->client_flag&= ~CLIENT_LOCAL_FILES;
702
break;
703
case 22:
704
options->client_flag&= ~CLIENT_LOCAL_FILES;
702
705
break;
703
case 24: /* max-allowed-packet */
706
case 24: /* max-allowed-packet */
704
707
if (opt_arg)
705
options->max_allowed_packet= atoi(opt_arg);
706
break;
708
options->max_allowed_packet= atoi(opt_arg);
709
break;
707
710
case 25: /* protocol */
708
711
if ((options->protocol= find_type(opt_arg,
709
&sql_protocol_typelib,0)) <= 0)
712
&sql_protocol_typelib,0)) <= 0)
710
713
{
711
714
fprintf(stderr, "Unknown option to protocol: %s\n", opt_arg);
712
715
exit(1);
719
722
options->shared_memory_base_name=my_strdup(opt_arg,MYF(MY_WME));
720
723
#endif
721
724
break;
722
case 27: /* multi-results */
723
options->client_flag|= CLIENT_MULTI_RESULTS;
724
break;
725
case 28: /* multi-statements */
726
case 29: /* multi-queries */
727
options->client_flag|= CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS;
728
break;
725
case 27: /* multi-results */
726
options->client_flag|= CLIENT_MULTI_RESULTS;
727
break;
728
case 28: /* multi-statements */
729
case 29: /* multi-queries */
730
options->client_flag|= CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS;
731
break;
729
732
case 30: /* secure-auth */
730
733
options->secure_auth= true;
731
734
break;
732
735
case 31: /* report-data-truncation */
733
736
options->report_data_truncation= opt_arg ? test(atoi(opt_arg)) : 1;
734
737
break;
735
default:
738
default:
736
739
break;
737
}
740
}
738
741
}
739
742
}
740
743
}
745
748
746
749
/**************************************************************************
747
750
Get column lengths of the current row
748
If one uses mysql_use_result, res->lengths contains the length information,
751
If one uses drizzle_use_result, res->lengths contains the length information,
749
752
else the lengths are calculated from the offset between pointers.
750
753
**************************************************************************/
751
754
752
static void cli_fetch_lengths(uint32_t *to, MYSQL_ROW column, uint32_t field_count)
753
{
755
static void cli_fetch_lengths(uint32_t *to, DRIZZLE_ROW column, uint32_t field_count)
756
{
754
757
uint32_t *prev_length;
755
758
char *start=0;
756
MYSQL_ROW end;
759
DRIZZLE_ROW end;
757
760
758
prev_length=0; /* Keep gcc happy */
761
prev_length=0; /* Keep gcc happy */
759
762
for (end=column + field_count + 1 ; column != end ; column++, to++)
760
763
{
761
764
if (!*column)
762
765
{
763
*to= 0; /* Null */
766
*to= 0; /* Null */
764
767
continue;
765
768
}
766
if (start) /* Found end of prev string */
769
if (start) /* Found end of prev string */
767
770
*prev_length= (ulong) (*column-start-1);
768
771
start= *column;
769
772
prev_length= to;
774
777
Change field rows to field structs
775
778
***************************************************************************/
776
779
777
MYSQL_FIELD *
778
unpack_fields(MYSQL_DATA *data,MEM_ROOT *alloc,uint fields,
779
my_bool default_value, uint server_capabilities)
780
DRIZZLE_FIELD *
781
unpack_fields(DRIZZLE_DATA *data,MEM_ROOT *alloc,uint fields,
782
my_bool default_value, uint server_capabilities)
780
783
{
781
MYSQL_ROWS *row;
782
MYSQL_FIELD *field,*result;
783
uint32_t lengths[9]; /* Max of fields */
784
DRIZZLE_ROWS *row;
785
DRIZZLE_FIELD *field,*result;
786
uint32_t lengths[9]; /* Max of fields */
784
787
785
field= result= (MYSQL_FIELD*) alloc_root(alloc,
786
(uint) sizeof(*field)*fields);
788
field= result= (DRIZZLE_FIELD*) alloc_root(alloc,
789
(uint) sizeof(*field)*fields);
787
790
if (!result)
788
791
{
789
free_rows(data); /* Free old data */
792
free_rows(data); /* Free old data */
790
793
return(0);
791
794
}
792
bzero((char*) field, (uint) sizeof(MYSQL_FIELD)*fields);
795
bzero((char*) field, (uint) sizeof(DRIZZLE_FIELD)*fields);
793
796
if (server_capabilities & CLIENT_PROTOCOL_41)
794
797
{
795
798
/* server is 4.1, and returns the new field result format */
806
809
field->name= strmake_root(alloc,(char*) row->data[4], lengths[4]);
807
810
field->org_name= strmake_root(alloc,(char*) row->data[5], lengths[5]);
808
811
809
field->catalog_length= lengths[0];
810
field->db_length= lengths[1];
811
field->table_length= lengths[2];
812
field->org_table_length= lengths[3];
813
field->name_length= lengths[4];
814
field->org_name_length= lengths[5];
812
field->catalog_length= lengths[0];
813
field->db_length= lengths[1];
814
field->table_length= lengths[2];
815
field->org_table_length= lengths[3];
816
field->name_length= lengths[4];
817
field->org_name_length= lengths[5];
815
818
816
819
/* Unpack fixed length parts */
817
820
pos= (uchar*) row->data[6];
818
821
field->charsetnr= uint2korr(pos);
819
field->length= (uint) uint4korr(pos+2);
820
field->type= (enum enum_field_types) pos[6];
821
field->flags= uint2korr(pos+7);
822
field->length= (uint) uint4korr(pos+2);
823
field->type= (enum enum_field_types) pos[6];
824
field->flags= uint2korr(pos+7);
822
825
field->decimals= (uint) pos[9];
823
826
824
827
if (INTERNAL_NUM_FIELD(field))
826
829
if (default_value && row->data[7])
827
830
{
828
831
field->def=strmake_root(alloc,(char*) row->data[7], lengths[7]);
829
field->def_length= lengths[7];
832
field->def_length= lengths[7];
830
833
}
831
834
else
832
835
field->def=0;
849
852
field->db= (char*) "";
850
853
field->catalog_length= 0;
851
854
field->db_length= 0;
852
field->org_table_length= field->table_length= lengths[0];
853
field->name_length= lengths[1];
855
field->org_table_length= field->table_length= lengths[0];
856
field->name_length= lengths[1];
854
857
855
858
if (server_capabilities & CLIENT_LONG_FLAG)
856
859
{
867
870
if (default_value && row->data[5])
868
871
{
869
872
field->def=strdup_root(alloc,(char*) row->data[5]);
870
field->def_length= lengths[5];
873
field->def_length= lengths[5];
871
874
}
872
875
else
873
876
field->def=0;
875
878
}
876
879
}
877
880
#endif /* DELETE_SUPPORT_OF_4_0_PROTOCOL */
878
free_rows(data); /* Free old data */
881
free_rows(data); /* Free old data */
879
882
return(result);
880
883
}
881
884
882
885
/* Read all rows (fields or data) from server */
883
886
884
MYSQL_DATA *cli_read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
885
unsigned int fields)
887
DRIZZLE_DATA *cli_read_rows(DRIZZLE *drizzle,DRIZZLE_FIELD *DRIZZLE_FIELDs,
888
unsigned int fields)
886
889
{
887
uint field;
890
uint field;
888
891
ulong pkt_len;
889
892
ulong len;
890
893
uchar *cp;
891
char *to, *end_to;
892
MYSQL_DATA *result;
893
MYSQL_ROWS **prev_ptr,*cur;
894
NET *net = &mysql->net;
894
char *to, *end_to;
895
DRIZZLE_DATA *result;
896
DRIZZLE_ROWS **prev_ptr,*cur;
897
NET *net = &drizzle->net;
895
898
896
if ((pkt_len= cli_safe_read(mysql)) == packet_error)
899
if ((pkt_len= cli_safe_read(drizzle)) == packet_error)
897
900
return(0);
898
if (!(result=(MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
899
MYF(MY_WME | MY_ZEROFILL))))
901
if (!(result=(DRIZZLE_DATA*) my_malloc(sizeof(DRIZZLE_DATA),
902
MYF(MY_WME | MY_ZEROFILL))))
900
903
{
901
set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
904
set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
902
905
return(0);
903
906
}
904
init_alloc_root(&result->alloc,8192,0); /* Assume rowlength < 8192 */
905
result->alloc.min_malloc=sizeof(MYSQL_ROWS);
907
init_alloc_root(&result->alloc,8192,0); /* Assume rowlength < 8192 */
908
result->alloc.min_malloc=sizeof(DRIZZLE_ROWS);
906
909
prev_ptr= &result->data;
907
910
result->rows=0;
908
911
result->fields=fields;
909
912
910
913
/*
911
The last EOF packet is either a single 254 character or (in MySQL 4.1)
914
The last EOF packet is either a single 254 character or (in DRIZZLE 4.1)
912
915
254 followed by 1-7 status bytes.
913
916
914
917
This doesn't conflict with normal usage of 254 which stands for a
918
921
while (*(cp=net->read_pos) != 254 || pkt_len >= 8)
919
922
{
920
923
result->rows++;
921
if (!(cur= (MYSQL_ROWS*) alloc_root(&result->alloc,
922
sizeof(MYSQL_ROWS))) ||
923
!(cur->data= ((MYSQL_ROW)
924
alloc_root(&result->alloc,
925
(fields+1)*sizeof(char *)+pkt_len))))
924
if (!(cur= (DRIZZLE_ROWS*) alloc_root(&result->alloc,
925
sizeof(DRIZZLE_ROWS))) ||
926
!(cur->data= ((DRIZZLE_ROW)
927
alloc_root(&result->alloc,
928
(fields+1)*sizeof(char *)+pkt_len))))
926
929
{
927
930
free_rows(result);
928
set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
931
set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
929
932
return(0);
930
933
}
931
934
*prev_ptr=cur;
935
938
for (field=0 ; field < fields ; field++)
936
939
{
937
940
if ((len=(ulong) net_field_length(&cp)) == NULL_LENGTH)
938
{ /* null field */
939
cur->data[field] = 0;
941
{ /* null field */
942
cur->data[field] = 0;
940
943
}
941
944
else
942
945
{
943
cur->data[field] = to;
946
cur->data[field] = to;
944
947
if (len > (ulong) (end_to - to))
945
948
{
946
949
free_rows(result);
947
set_mysql_error(mysql, CR_MALFORMED_PACKET, unknown_sqlstate);
950
set_drizzle_error(drizzle, CR_MALFORMED_PACKET, unknown_sqlstate);
948
951
return(0);
949
952
}
950
memcpy(to,(char*) cp,len); to[len]=0;
951
to+=len+1;
952
cp+=len;
953
if (mysql_fields)
954
{
955
if (mysql_fields[field].max_length < len)
956
mysql_fields[field].max_length=len;
957
}
953
memcpy(to,(char*) cp,len); to[len]=0;
954
to+=len+1;
955
cp+=len;
956
if (DRIZZLE_FIELDs)
957
{
958
if (DRIZZLE_FIELDs[field].max_length < len)
959
DRIZZLE_FIELDs[field].max_length=len;
960
}
958
961
}
959
962
}
960
cur->data[field]=to; /* End of last field */
961
if ((pkt_len=cli_safe_read(mysql)) == packet_error)
963
cur->data[field]=to; /* End of last field */
964
if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
962
965
{
963
966
free_rows(result);
964
967
return(0);
965
968
}
966
969
}
967
*prev_ptr=0; /* last pointer is null */
968
if (pkt_len > 1) /* MySQL 4.1 protocol */
970
*prev_ptr=0; /* last pointer is null */
971
if (pkt_len > 1) /* DRIZZLE 4.1 protocol */
969
972
{
970
mysql->warning_count= uint2korr(cp+1);
971
mysql->server_status= uint2korr(cp+3);
973
drizzle->warning_count= uint2korr(cp+1);
974
drizzle->server_status= uint2korr(cp+3);
972
975
}
973
976
return(result);
974
977
}
980
983
981
984
982
985
static int32_t
983
read_one_row(MYSQL *mysql, uint32_t fields, MYSQL_ROW row, uint32_t *lengths)
986
read_one_row(DRIZZLE *drizzle, uint32_t fields, DRIZZLE_ROW row, uint32_t *lengths)
984
987
{
985
988
uint field;
986
989
ulong pkt_len,len;
987
990
uchar *pos, *prev_pos, *end_pos;
988
NET *net= &mysql->net;
991
NET *net= &drizzle->net;
989
992
990
if ((pkt_len=cli_safe_read(mysql)) == packet_error)
993
if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
991
994
return -1;
992
995
if (pkt_len <= 8 && net->read_pos[0] == 254)
993
996
{
994
if (pkt_len > 1) /* MySQL 4.1 protocol */
997
if (pkt_len > 1) /* DRIZZLE 4.1 protocol */
995
998
{
996
mysql->warning_count= uint2korr(net->read_pos+1);
997
mysql->server_status= uint2korr(net->read_pos+3);
999
drizzle->warning_count= uint2korr(net->read_pos+1);
1000
drizzle->server_status= uint2korr(net->read_pos+3);
998
1001
}
999
return 1; /* End of data */
1002
return 1; /* End of data */
1000
1003
}
1001
prev_pos= 0; /* allowed to write at packet[-1] */
1004
prev_pos= 0; /* allowed to write at packet[-1] */
1002
1005
pos=net->read_pos;
1003
1006
end_pos=pos+pkt_len;
1004
1007
for (field=0 ; field < fields ; field++)
1005
1008
{
1006
1009
if ((len=(ulong) net_field_length(&pos)) == NULL_LENGTH)
1007
{ /* null field */
1010
{ /* null field */
1008
1011
row[field] = 0;
1009
1012
*lengths++=0;
1010
1013
}
1012
1015
{
1013
1016
if (len > (ulong) (end_pos - pos))
1014
1017
{
1015
set_mysql_error(mysql, CR_UNKNOWN_ERROR, unknown_sqlstate);
1018
set_drizzle_error(drizzle, CR_UNKNOWN_ERROR, unknown_sqlstate);
1016
1019
return -1;
1017
1020
}
1018
1021
row[field] = (char*) pos;
1020
1023
*lengths++=len;
1021
1024
}
1022
1025
if (prev_pos)
1023
*prev_pos=0; /* Terminate prev field */
1026
*prev_pos=0; /* Terminate prev field */
1024
1027
prev_pos=pos;
1025
1028
}
1026
row[field]=(char*) prev_pos+1; /* End of last field */
1027
*prev_pos=0; /* Terminate last field */
1029
row[field]=(char*) prev_pos+1; /* End of last field */
1030
*prev_pos=0; /* Terminate last field */
1028
1031
return 0;
1029
1032
}
1030
1033
1031
1034
1032
1035
/****************************************************************************
1033
Init MySQL structure or allocate one
1036
Init DRIZZLE structure or allocate one
1034
1037
****************************************************************************/
1035
1038
1036
MYSQL * STDCALL
1037
mysql_init(MYSQL *mysql)
1039
DRIZZLE *
1040
drizzle_create(DRIZZLE *ptr)
1038
1041
{
1039
if (mysql_server_init(0, NULL, NULL))
1040
return 0;
1041
if (!mysql)
1042
{
1043
if (!(mysql=(MYSQL*) my_malloc(sizeof(*mysql),MYF(MY_WME | MY_ZEROFILL))))
1044
{
1045
set_mysql_error(NULL, CR_OUT_OF_MEMORY, unknown_sqlstate);
1042
1043
if (!drizzle_client_init)
1044
{
1045
drizzle_client_init=true;
1046
org_my_init_done=my_init_done;
1047
1048
/* Will init threads */
1049
if (my_init())
1050
return NULL;
1051
1052
init_client_errs();
1053
1054
if (!drizzle_port)
1055
{
1056
drizzle_port = MYSQL_PORT;
1057
{
1058
struct servent *serv_ptr;
1059
char *env;
1060
1061
/*
1062
if builder specifically requested a default port, use that
1063
(even if it coincides with our factory default).
1064
only if they didn't do we check /etc/services (and, failing
1065
on that, fall back to the factory default of 4427).
1066
either default can be overridden by the environment variable
1067
MYSQL_TCP_PORT, which in turn can be overridden with command
1068
line options.
1069
*/
1070
1071
#if MYSQL_PORT_DEFAULT == 0
1072
if ((serv_ptr = getservbyname("drizzle", "tcp")))
1073
drizzle_port = (uint) ntohs((ushort) serv_ptr->s_port);
1074
#endif
1075
if ((env = getenv("DRIZZLE_TCP_PORT")))
1076
drizzle_port =(uint) atoi(env);
1077
}
1078
}
1079
if (!drizzle_unix_port)
1080
{
1081
char *env;
1082
drizzle_unix_port = (char*) MYSQL_UNIX_ADDR;
1083
if ((env = getenv("DRIZZLE_UNIX_PORT")))
1084
drizzle_unix_port = env;
1085
}
1086
#if defined(SIGPIPE)
1087
(void) signal(SIGPIPE, SIG_IGN);
1088
#endif
1089
}
1090
else
1091
/* Init if new thread */
1092
if (my_thread_init())
1093
return NULL;
1094
1095
if (ptr == NULL)
1096
{
1097
ptr= (DRIZZLE *) malloc(sizeof(DRIZZLE));
1098
1099
if (ptr == NULL)
1100
{
1101
set_drizzle_error(NULL, CR_OUT_OF_MEMORY, unknown_sqlstate);
1046
1102
return 0;
1047
1103
}
1048
mysql->free_me=1;
1104
memset(ptr, 0, sizeof(DRIZZLE));
1105
ptr->free_me=1;
1049
1106
}
1050
1107
else
1051
bzero((char*) (mysql), sizeof(*(mysql)));
1052
mysql->options.connect_timeout= CONNECT_TIMEOUT;
1053
mysql->charset=default_client_charset_info;
1054
strmov(mysql->net.sqlstate, not_error_sqlstate);
1108
{
1109
memset(ptr, 0, sizeof(DRIZZLE));
1110
}
1111
1112
ptr->options.connect_timeout= CONNECT_TIMEOUT;
1113
ptr->charset=default_client_charset_info;
1114
strcpy(ptr->net.sqlstate, not_error_sqlstate);
1055
1115
1056
1116
/*
1057
1117
Only enable LOAD DATA INFILE by default if configured with
1058
1118
--enable-local-infile
1059
1119
*/
1060
1120
1061
#if defined(ENABLED_LOCAL_INFILE) && !defined(MYSQL_SERVER)
1062
mysql->options.client_flag|= CLIENT_LOCAL_FILES;
1121
#if defined(ENABLED_LOCAL_INFILE) && !defined(DRIZZLE_SERVER)
1122
ptr->options.client_flag|= CLIENT_LOCAL_FILES;
1063
1123
#endif
1064
1124
1065
1125
#ifdef HAVE_SMEM
1066
mysql->options.shared_memory_base_name= (char*) def_shared_memory_base_name;
1126
ptr->options.shared_memory_base_name= (char*) def_shared_memory_base_name;
1067
1127
#endif
1068
1128
1069
mysql->options.methods_to_use= MYSQL_OPT_GUESS_CONNECTION;
1070
mysql->options.report_data_truncation= true; /* default */
1129
ptr->options.methods_to_use= DRIZZLE_OPT_GUESS_CONNECTION;
1130
ptr->options.report_data_truncation= true; /* default */
1071
1131
1072
1132
/*
1073
1133
By default we don't reconnect because it could silently corrupt data (after
1074
1134
reconnection you potentially lose table locks, user variables, session
1075
1135
variables (transactions but they are specifically dealt with in
1076
mysql_reconnect()).
1077
This is a change: < 5.0.3 mysql->reconnect was set to 1 by default.
1136
drizzle_reconnect()).
1137
This is a change: < 5.0.3 drizzle->reconnect was set to 1 by default.
1078
1138
How this change impacts existing apps:
1079
1139
- existing apps which relyed on the default will see a behaviour change;
1080
they will have to set reconnect=1 after mysql_real_connect().
1140
they will have to set reconnect=1 after drizzle_connect().
1081
1141
- existing apps which explicitely asked for reconnection (the only way they
1082
could do it was by setting mysql.reconnect to 1 after mysql_real_connect())
1142
could do it was by setting drizzle.reconnect to 1 after drizzle_connect())
1083
1143
will not see a behaviour change.
1084
1144
- existing apps which explicitely asked for no reconnection
1085
(mysql.reconnect=0) will not see a behaviour change.
1145
(drizzle.reconnect=0) will not see a behaviour change.
1086
1146
*/
1087
mysql->reconnect= 0;
1088
1089
return mysql;
1090
}
1091
1092
1093
/*
1094
Fill in SSL part of MYSQL structure and set 'use_ssl' flag.
1095
NB! Errors are not reported until you do mysql_real_connect.
1147
ptr->reconnect= 0;
1148
1149
return ptr;
1150
}
1151
1152
1153
/*
1154
Free all memory and resources used by the client library
1155
1156
NOTES
1157
When calling this there should not be any other threads using
1158
the library.
1159
1160
To make things simpler when used with windows dll's (which calls this
1161
function automaticly), it's safe to call this function multiple times.
1162
*/
1163
1164
1165
void STDCALL drizzle_server_end()
1166
{
1167
if (!drizzle_client_init)
1168
return;
1169
1170
finish_client_errs();
1171
vio_end();
1172
1173
/* If library called my_init(), free memory allocated by it */
1174
if (!org_my_init_done)
1175
{
1176
my_end(0);
1177
}
1178
else
1179
{
1180
free_charsets();
1181
drizzle_thread_end();
1182
}
1183
1184
drizzle_client_init= org_my_init_done= 0;
1185
#ifdef EMBEDDED_SERVER
1186
if (stderror_file)
1187
{
1188
fclose(stderror_file);
1189
stderror_file= 0;
1190
}
1191
#endif
1192
}
1193
1194
1195
/*
1196
Fill in SSL part of DRIZZLE structure and set 'use_ssl' flag.
1197
NB! Errors are not reported until you do drizzle_connect.
1096
1198
*/
1097
1199
1098
1200
#define strdup_if_not_null(A) (A) == 0 ? 0 : my_strdup((A),MYF(MY_WME))
1099
1201
1100
1202
/*
1101
Note that the mysql argument must be initialized with mysql_init()
1102
before calling mysql_real_connect !
1203
Note that the drizzle argument must be initialized with drizzle_init()
1204
before calling drizzle_connect !
1103
1205
*/
1104
1206
1105
static bool cli_read_query_result(MYSQL *mysql);
1106
static MYSQL_RES *cli_use_result(MYSQL *mysql);
1207
static bool cli_read_query_result(DRIZZLE *drizzle);
1208
static DRIZZLE_RES *cli_use_result(DRIZZLE *drizzle);
1107
1209
1108
static MYSQL_METHODS client_methods=
1210
static DRIZZLE_METHODS client_methods=
1109
1211
{
1110
1212
cli_read_query_result, /* read_query_result */
1111
1213
cli_advanced_command, /* advanced_command */
1125
1227
};
1126
1228
1127
1229
C_MODE_START
1128
int mysql_init_character_set(MYSQL *mysql)
1230
int drizzle_init_character_set(DRIZZLE *drizzle)
1129
1231
{
1130
1232
const char *default_collation_name;
1131
1233
1132
1234
/* Set character set */
1133
if (!mysql->options.charset_name)
1235
if (!drizzle->options.charset_name)
1134
1236
{
1135
1237
default_collation_name= MYSQL_DEFAULT_COLLATION_NAME;
1136
if (!(mysql->options.charset_name=
1238
if (!(drizzle->options.charset_name=
1137
1239
my_strdup(MYSQL_DEFAULT_CHARSET_NAME,MYF(MY_WME))))
1138
1240
return 1;
1139
1241
}
1140
1242
else
1141
1243
default_collation_name= NULL;
1142
1244
1143
1245
{
1144
1246
const char *save= charsets_dir;
1145
if (mysql->options.charset_dir)
1146
charsets_dir=mysql->options.charset_dir;
1147
mysql->charset=get_charset_by_csname(mysql->options.charset_name,
1247
if (drizzle->options.charset_dir)
1248
charsets_dir=drizzle->options.charset_dir;
1249
drizzle->charset=get_charset_by_csname(drizzle->options.charset_name,
1148
1250
MY_CS_PRIMARY, MYF(MY_WME));
1149
if (mysql->charset && default_collation_name)
1251
if (drizzle->charset && default_collation_name)
1150
1252
{
1151
1253
CHARSET_INFO *collation;
1152
if ((collation=
1254
if ((collation=
1153
1255
get_charset_by_name(default_collation_name, MYF(MY_WME))))
1154
1256
{
1155
if (!my_charset_same(mysql->charset, collation))
1257
if (!my_charset_same(drizzle->charset, collation))
1156
1258
{
1157
my_printf_error(ER_UNKNOWN_ERROR,
1259
my_printf_error(ER_UNKNOWN_ERROR,
1158
1260
"COLLATION %s is not valid for CHARACTER SET %s",
1159
1261
MYF(0),
1160
default_collation_name, mysql->options.charset_name);
1161
mysql->charset= NULL;
1262
default_collation_name, drizzle->options.charset_name);
1263
drizzle->charset= NULL;
1162
1264
}
1163
1265
else
1164
1266
{
1165
mysql->charset= collation;
1267
drizzle->charset= collation;
1166
1268
}
1167
1269
}
1168
1270
else
1169
mysql->charset= NULL;
1271
drizzle->charset= NULL;
1170
1272
}
1171
1273
charsets_dir= save;
1172
1274
}
1173
1275
1174
if (!mysql->charset)
1276
if (!drizzle->charset)
1175
1277
{
1176
if (mysql->options.charset_dir)
1177
set_mysql_extended_error(mysql, CR_CANT_READ_CHARSET, unknown_sqlstate,
1278
if (drizzle->options.charset_dir)
1279
set_drizzle_extended_error(drizzle, CR_CANT_READ_CHARSET, unknown_sqlstate,
1178
1280
ER(CR_CANT_READ_CHARSET),
1179
mysql->options.charset_name,
1180
mysql->options.charset_dir);
1281
drizzle->options.charset_name,
1282
drizzle->options.charset_dir);
1181
1283
else
1182
1284
{
1183
1285
char cs_dir_name[FN_REFLEN];
1184
1286
get_charsets_dir(cs_dir_name);
1185
set_mysql_extended_error(mysql, CR_CANT_READ_CHARSET, unknown_sqlstate,
1287
set_drizzle_extended_error(drizzle, CR_CANT_READ_CHARSET, unknown_sqlstate,
1186
1288
ER(CR_CANT_READ_CHARSET),
1187
mysql->options.charset_name,
1289
drizzle->options.charset_name,
1188
1290
cs_dir_name);
1189
1291
}
1190
1292
return 1;
1194
1296
C_MODE_END
1195
1297
1196
1298
1197
MYSQL * STDCALL
1198
CLI_MYSQL_REAL_CONNECT(MYSQL *mysql,const char *host, const char *user,
1299
DRIZZLE * STDCALL
1300
CLI_DRIZZLE_CONNECT(DRIZZLE *drizzle,const char *host, const char *user,
1199
1301
const char *passwd, const char *db,
1200
1302
uint32_t port, const char *unix_socket, uint32_t client_flag)
1201
1303
{
1202
1304
char buff[NAME_LEN+USERNAME_LENGTH+100];
1203
1305
char *end,*host_info=NULL;
1204
1306
uint32_t pkt_length;
1205
NET *net= &mysql->net;
1307
NET *net= &drizzle->net;
1206
1308
struct sockaddr_un UNIXaddr;
1207
1309
init_sigpipe_variables
1208
1310
1209
1311
/* Don't give sigpipe errors if the client doesn't want them */
1210
set_sigpipe(mysql);
1211
mysql->methods= &client_methods;
1212
net->vio = 0; /* If something goes wrong */
1213
mysql->client_flag=0; /* For handshake */
1312
set_sigpipe(drizzle);
1313
drizzle->methods= &client_methods;
1314
net->vio = 0; /* If something goes wrong */
1315
drizzle->client_flag=0; /* For handshake */
1214
1316
1215
1317
/* use default options */
1216
if (mysql->options.my_cnf_file || mysql->options.my_cnf_group)
1318
if (drizzle->options.my_cnf_file || drizzle->options.my_cnf_group)
1217
1319
{
1218
mysql_read_default_options(&mysql->options,
1219
(mysql->options.my_cnf_file ?
1220
mysql->options.my_cnf_file : "my"),
1221
mysql->options.my_cnf_group);
1222
my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
1223
my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
1224
mysql->options.my_cnf_file=mysql->options.my_cnf_group=0;
1320
drizzle_read_default_options(&drizzle->options,
1321
(drizzle->options.my_cnf_file ?
1322
drizzle->options.my_cnf_file : "my"),
1323
drizzle->options.my_cnf_group);
1324
my_free(drizzle->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
1325
my_free(drizzle->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
1326
drizzle->options.my_cnf_file=drizzle->options.my_cnf_group=0;
1225
1327
}
1226
1328
1227
1329
/* Some empty-string-tests are done because of ODBC */
1228
1330
if (!host || !host[0])
1229
host=mysql->options.host;
1331
host=drizzle->options.host;
1230
1332
if (!user || !user[0])
1231
1333
{
1232
user=mysql->options.user;
1334
user=drizzle->options.user;
1233
1335
if (!user)
1234
1336
user= "";
1235
1337
}
1236
1338
if (!passwd)
1237
1339
{
1238
passwd=mysql->options.password;
1340
passwd=drizzle->options.password;
1239
1341
if (!passwd)
1240
1342
passwd= "";
1241
1343
}
1242
1344
if (!db || !db[0])
1243
db=mysql->options.db;
1345
db=drizzle->options.db;
1244
1346
if (!port)
1245
port=mysql->options.port;
1347
port=drizzle->options.port;
1246
1348
if (!unix_socket)
1247
unix_socket=mysql->options.unix_socket;
1349
unix_socket=drizzle->options.unix_socket;
1248
1350
1249
mysql->server_status=SERVER_STATUS_AUTOCOMMIT;
1351
drizzle->server_status=SERVER_STATUS_AUTOCOMMIT;
1250
1352
1251
1353
/*
1252
1354
Part 0: Grab a socket and connect it to the server
1253
1355
*/
1254
1356
#if defined(HAVE_SMEM)
1255
if ((!mysql->options.protocol ||
1256
mysql->options.protocol == MYSQL_PROTOCOL_MEMORY) &&
1357
if ((!drizzle->options.protocol ||
1358
drizzle->options.protocol == DRIZZLE_PROTOCOL_MEMORY) &&
1257
1359
(!host || !strcmp(host,LOCAL_HOST)))
1258
1360
{
1259
if ((create_shared_memory(mysql,net, mysql->options.connect_timeout)) ==
1260
INVALID_HANDLE_VALUE)
1361
if ((create_shared_memory(drizzle,net, drizzle->options.connect_timeout)) ==
1362
INVALID_HANDLE_VALUE)
1261
1363
{
1262
if (mysql->options.protocol == MYSQL_PROTOCOL_MEMORY)
1263
goto error;
1364
if (drizzle->options.protocol == DRIZZLE_PROTOCOL_MEMORY)
1365
goto error;
1264
1366
1265
1367
/*
1266
1368
Try also with PIPE or TCP/IP. Clear the error from
1271
1373
}
1272
1374
else
1273
1375
{
1274
mysql->options.protocol=MYSQL_PROTOCOL_MEMORY;
1376
drizzle->options.protocol=DRIZZLE_PROTOCOL_MEMORY;
1275
1377
unix_socket = 0;
1276
host=mysql->options.shared_memory_base_name;
1378
host=drizzle->options.shared_memory_base_name;
1277
1379
snprintf(host_info=buff, sizeof(buff)-1,
1278
1380
ER(CR_SHARED_MEMORY_CONNECTION), host);
1279
1381
}
1280
1382
}
1281
1383
#endif /* HAVE_SMEM */
1282
1384
if (!net->vio &&
1283
(!mysql->options.protocol ||
1284
mysql->options.protocol == MYSQL_PROTOCOL_SOCKET) &&
1285
(unix_socket || mysql_unix_port) &&
1385
(!drizzle->options.protocol ||
1386
drizzle->options.protocol == DRIZZLE_PROTOCOL_SOCKET) &&
1387
(unix_socket || drizzle_unix_port) &&
1286
1388
(!host || !strcmp(host,LOCAL_HOST)))
1287
1389
{
1288
1390
my_socket sock= socket(AF_UNIX, SOCK_STREAM, 0);
1289
1391
if (sock == SOCKET_ERROR)
1290
1392
{
1291
set_mysql_extended_error(mysql, CR_SOCKET_CREATE_ERROR,
1393
set_drizzle_extended_error(drizzle, CR_SOCKET_CREATE_ERROR,
1292
1394
unknown_sqlstate,
1293
1395
ER(CR_SOCKET_CREATE_ERROR),
1294
1396
socket_errno);
1299
1401
VIO_LOCALHOST | VIO_BUFFERED_READ);
1300
1402
if (!net->vio)
1301
1403
{
1302
set_mysql_error(mysql, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
1404
set_drizzle_error(drizzle, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
1303
1405
closesocket(sock);
1304
1406
goto error;
1305
1407
}
1306
1408
1307
1409
host= LOCAL_HOST;
1308
1410
if (!unix_socket)
1309
unix_socket= mysql_unix_port;
1411
unix_socket= drizzle_unix_port;
1310
1412
host_info= (char*) ER(CR_LOCALHOST_CONNECTION);
1311
1413
1312
1414
bzero((char*) &UNIXaddr, sizeof(UNIXaddr));
1314
1416
strmake(UNIXaddr.sun_path, unix_socket, sizeof(UNIXaddr.sun_path)-1);
1315
1417
1316
1418
if (my_connect(sock, (struct sockaddr *) &UNIXaddr, sizeof(UNIXaddr),
1317
mysql->options.connect_timeout))
1419
drizzle->options.connect_timeout))
1318
1420
{
1319
set_mysql_extended_error(mysql, CR_CONNECTION_ERROR,
1421
set_drizzle_extended_error(drizzle, CR_CONNECTION_ERROR,
1320
1422
unknown_sqlstate,
1321
1423
ER(CR_CONNECTION_ERROR),
1322
1424
unix_socket, socket_errno);
1324
1426
net->vio= 0;
1325
1427
goto error;
1326
1428
}
1327
mysql->options.protocol=MYSQL_PROTOCOL_SOCKET;
1429
drizzle->options.protocol=DRIZZLE_PROTOCOL_SOCKET;
1328
1430
}
1329
1431
if (!net->vio &&
1330
(!mysql->options.protocol ||
1331
mysql->options.protocol == MYSQL_PROTOCOL_TCP))
1432
(!drizzle->options.protocol ||
1433
drizzle->options.protocol == DRIZZLE_PROTOCOL_TCP))
1332
1434
{
1333
1435
struct addrinfo *res_lst, hints, *t_res;
1334
1436
int gai_errno;
1335
1437
char port_buf[NI_MAXSERV];
1336
1438
1337
unix_socket=0; /* This is not used */
1439
unix_socket=0; /* This is not used */
1338
1440
1339
1441
if (!port)
1340
port= mysql_port;
1442
port= drizzle_port;
1341
1443
1342
1444
if (!host)
1343
1445
host= LOCAL_HOST;
1352
1454
snprintf(port_buf, NI_MAXSERV, "%d", port);
1353
1455
gai_errno= getaddrinfo(host, port_buf, &hints, &res_lst);
1354
1456
1355
if (gai_errno != 0)
1356
{
1357
set_mysql_extended_error(mysql, CR_UNKNOWN_HOST, unknown_sqlstate,
1457
if (gai_errno != 0)
1458
{
1459
set_drizzle_extended_error(drizzle, CR_UNKNOWN_HOST, unknown_sqlstate,
1358
1460
ER(CR_UNKNOWN_HOST), host, errno);
1359
1461
1360
1462
goto error;
1361
1463
}
1362
1464
1363
1465
/* We only look at the first item (something to think about changing in the future) */
1364
t_res= res_lst;
1466
t_res= res_lst;
1365
1467
{
1366
1468
my_socket sock= socket(t_res->ai_family, t_res->ai_socktype,
1367
1469
t_res->ai_protocol);
1368
1470
if (sock == SOCKET_ERROR)
1369
1471
{
1370
set_mysql_extended_error(mysql, CR_IPSOCK_ERROR, unknown_sqlstate,
1472
set_drizzle_extended_error(drizzle, CR_IPSOCK_ERROR, unknown_sqlstate,
1371
1473
ER(CR_IPSOCK_ERROR), socket_errno);
1372
1474
freeaddrinfo(res_lst);
1373
1475
goto error;
1376
1478
net->vio= vio_new(sock, VIO_TYPE_TCPIP, VIO_BUFFERED_READ);
1377
1479
if (! net->vio )
1378
1480
{
1379
set_mysql_error(mysql, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
1481
set_drizzle_error(drizzle, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
1380
1482
closesocket(sock);
1381
1483
freeaddrinfo(res_lst);
1382
1484
goto error;
1383
1485
}
1384
1486
1385
1487
if (my_connect(sock, t_res->ai_addr, t_res->ai_addrlen,
1386
mysql->options.connect_timeout))
1488
drizzle->options.connect_timeout))
1387
1489
{
1388
set_mysql_extended_error(mysql, CR_CONN_HOST_ERROR, unknown_sqlstate,
1490
set_drizzle_extended_error(drizzle, CR_CONN_HOST_ERROR, unknown_sqlstate,
1389
1491
ER(CR_CONN_HOST_ERROR), host, socket_errno);
1390
1492
vio_delete(net->vio);
1391
1493
net->vio= 0;
1399
1501
1400
1502
if (!net->vio)
1401
1503
{
1402
set_mysql_error(mysql, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
1504
set_drizzle_error(drizzle, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
1403
1505
goto error;
1404
1506
}
1405
1507
1407
1509
{
1408
1510
vio_delete(net->vio);
1409
1511
net->vio = 0;
1410
set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
1512
set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
1411
1513
goto error;
1412
1514
}
1413
1515
vio_keepalive(net->vio,true);
1414
1516
1415
1517
/* If user set read_timeout, let it override the default */
1416
if (mysql->options.read_timeout)
1417
my_net_set_read_timeout(net, mysql->options.read_timeout);
1518
if (drizzle->options.read_timeout)
1519
my_net_set_read_timeout(net, drizzle->options.read_timeout);
1418
1520
1419
1521
/* If user set write_timeout, let it override the default */
1420
if (mysql->options.write_timeout)
1421
my_net_set_write_timeout(net, mysql->options.write_timeout);
1522
if (drizzle->options.write_timeout)
1523
my_net_set_write_timeout(net, drizzle->options.write_timeout);
1422
1524
1423
if (mysql->options.max_allowed_packet)
1424
net->max_packet_size= mysql->options.max_allowed_packet;
1525
if (drizzle->options.max_allowed_packet)
1526
net->max_packet_size= drizzle->options.max_allowed_packet;
1425
1527
1426
1528
/* Get version info */
1427
mysql->protocol_version= PROTOCOL_VERSION; /* Assume this */
1428
if (mysql->options.connect_timeout &&
1429
vio_poll_read(net->vio, mysql->options.connect_timeout))
1529
drizzle->protocol_version= PROTOCOL_VERSION; /* Assume this */
1530
if (drizzle->options.connect_timeout &&
1531
vio_poll_read(net->vio, drizzle->options.connect_timeout))
1430
1532
{
1431
set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
1533
set_drizzle_extended_error(drizzle, CR_SERVER_LOST, unknown_sqlstate,
1432
1534
ER(CR_SERVER_LOST_EXTENDED),
1433
1535
"waiting for initial communication packet",
1434
1536
errno);
1439
1541
Part 1: Connection established, read and parse first packet
1440
1542
*/
1441
1543
1442
if ((pkt_length=cli_safe_read(mysql)) == packet_error)
1544
if ((pkt_length=cli_safe_read(drizzle)) == packet_error)
1443
1545
{
1444
if (mysql->net.last_errno == CR_SERVER_LOST)
1445
set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
1546
if (drizzle->net.last_errno == CR_SERVER_LOST)
1547
set_drizzle_extended_error(drizzle, CR_SERVER_LOST, unknown_sqlstate,
1446
1548
ER(CR_SERVER_LOST_EXTENDED),
1447
1549
"reading initial communication packet",
1448
1550
errno);
1450
1552
}
1451
1553
/* Check if version of protocol matches current one */
1452
1554
1453
mysql->protocol_version= net->read_pos[0];
1454
if (mysql->protocol_version != PROTOCOL_VERSION)
1555
drizzle->protocol_version= net->read_pos[0];
1556
if (drizzle->protocol_version != PROTOCOL_VERSION)
1455
1557
{
1456
set_mysql_extended_error(mysql, CR_VERSION_ERROR, unknown_sqlstate,
1457
ER(CR_VERSION_ERROR), mysql->protocol_version,
1558
set_drizzle_extended_error(drizzle, CR_VERSION_ERROR, unknown_sqlstate,
1559
ER(CR_VERSION_ERROR), drizzle->protocol_version,
1458
1560
PROTOCOL_VERSION);
1459
1561
goto error;
1460
1562
}
1461
1563
end=strend((char*) net->read_pos+1);
1462
mysql->thread_id=uint4korr(end+1);
1564
drizzle->thread_id=uint4korr(end+1);
1463
1565
end+=5;
1464
/*
1566
/*
1465
1567
Scramble is split into two parts because old clients does not understand
1466
1568
long scrambles; here goes the first part.
1467
1569
*/
1468
strmake(mysql->scramble, end, SCRAMBLE_LENGTH_323);
1570
strmake(drizzle->scramble, end, SCRAMBLE_LENGTH_323);
1469
1571
end+= SCRAMBLE_LENGTH_323+1;
1470
1572
1471
1573
if (pkt_length >= (uint) (end+1 - (char*) net->read_pos))
1472
mysql->server_capabilities=uint2korr(end);
1574
drizzle->server_capabilities=uint2korr(end);
1473
1575
if (pkt_length >= (uint) (end+18 - (char*) net->read_pos))
1474
1576
{
1475
1577
/* New protocol with 16 bytes to describe server characteristics */
1476
mysql->server_language=end[2];
1477
mysql->server_status=uint2korr(end+3);
1578
drizzle->server_language=end[2];
1579
drizzle->server_status=uint2korr(end+3);
1478
1580
}
1479
1581
end+= 18;
1480
if (pkt_length >= (uint) (end + SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323 + 1 -
1582
if (pkt_length >= (uint) (end + SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323 + 1 -
1481
1583
(char *) net->read_pos))
1482
strmake(mysql->scramble+SCRAMBLE_LENGTH_323, end,
1584
strmake(drizzle->scramble+SCRAMBLE_LENGTH_323, end,
1483
1585
SCRAMBLE_LENGTH-SCRAMBLE_LENGTH_323);
1484
1586
else
1485
mysql->server_capabilities&= ~CLIENT_SECURE_CONNECTION;
1587
drizzle->server_capabilities&= ~CLIENT_SECURE_CONNECTION;
1486
1588
1487
if (mysql->options.secure_auth && passwd[0] &&
1488
!(mysql->server_capabilities & CLIENT_SECURE_CONNECTION))
1589
if (drizzle->options.secure_auth && passwd[0] &&
1590
!(drizzle->server_capabilities & CLIENT_SECURE_CONNECTION))
1489
1591
{
1490
set_mysql_error(mysql, CR_SECURE_AUTH, unknown_sqlstate);
1592
set_drizzle_error(drizzle, CR_SECURE_AUTH, unknown_sqlstate);
1491
1593
goto error;
1492
1594
}
1493
1595
1494
if (mysql_init_character_set(mysql))
1596
if (drizzle_init_character_set(drizzle))
1495
1597
goto error;
1496
1598
1497
1599
/* Save connection information */
1498
1600
if (!my_multi_malloc(MYF(0),
1499
&mysql->host_info, (uint) strlen(host_info)+1,
1500
&mysql->host, (uint) strlen(host)+1,
1501
&mysql->unix_socket,unix_socket ?
1502
(uint) strlen(unix_socket)+1 : (uint) 1,
1503
&mysql->server_version,
1504
(uint) (end - (char*) net->read_pos),
1505
NullS) ||
1506
!(mysql->user=my_strdup(user,MYF(0))) ||
1507
!(mysql->passwd=my_strdup(passwd,MYF(0))))
1601
&drizzle->host_info, (uint) strlen(host_info)+1,
1602
&drizzle->host, (uint) strlen(host)+1,
1603
&drizzle->unix_socket,unix_socket ?
1604
(uint) strlen(unix_socket)+1 : (uint) 1,
1605
&drizzle->server_version,
1606
(uint) (end - (char*) net->read_pos),
1607
NullS) ||
1608
!(drizzle->user=my_strdup(user,MYF(0))) ||
1609
!(drizzle->passwd=my_strdup(passwd,MYF(0))))
1508
1610
{
1509
set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
1611
set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
1510
1612
goto error;
1511
1613
}
1512
strmov(mysql->host_info,host_info);
1513
strmov(mysql->host,host);
1614
strmov(drizzle->host_info,host_info);
1615
strmov(drizzle->host,host);
1514
1616
if (unix_socket)
1515
strmov(mysql->unix_socket,unix_socket);
1617
strmov(drizzle->unix_socket,unix_socket);
1516
1618
else
1517
mysql->unix_socket=0;
1518
strmov(mysql->server_version,(char*) net->read_pos+1);
1519
mysql->port=port;
1619
drizzle->unix_socket=0;
1620
strmov(drizzle->server_version,(char*) net->read_pos+1);
1621
drizzle->port=port;
1520
1622
1521
1623
/*
1522
1624
Part 2: format and send client info to the server for access check
1523
1625
*/
1524
1525
client_flag|=mysql->options.client_flag;
1626
1627
client_flag|=drizzle->options.client_flag;
1526
1628
client_flag|=CLIENT_CAPABILITIES;
1527
1629
if (client_flag & CLIENT_MULTI_STATEMENTS)
1528
1630
client_flag|= CLIENT_MULTI_RESULTS;
1532
1634
1533
1635
/* Remove options that server doesn't support */
1534
1636
client_flag= ((client_flag &
1535
~(CLIENT_COMPRESS | CLIENT_SSL | CLIENT_PROTOCOL_41)) |
1536
(client_flag & mysql->server_capabilities));
1637
~(CLIENT_COMPRESS | CLIENT_SSL | CLIENT_PROTOCOL_41)) |
1638
(client_flag & drizzle->server_capabilities));
1537
1639
client_flag&= ~CLIENT_COMPRESS;
1538
1640
1539
1641
if (client_flag & CLIENT_PROTOCOL_41)
1541
1643
/* 4.1 server and 4.1 client has a 32 byte option flag */
1542
1644
int4store(buff,client_flag);
1543
1645
int4store(buff+4, net->max_packet_size);
1544
buff[8]= (char) mysql->charset->number;
1646
buff[8]= (char) drizzle->charset->number;
1545
1647
bzero(buff+9, 32-9);
1546
1648
end= buff+32;
1547
1649
}
1551
1653
int3store(buff+2,net->max_packet_size);
1552
1654
end= buff+5;
1553
1655
}
1554
mysql->client_flag=client_flag;
1656
drizzle->client_flag=client_flag;
1555
1657
1556
1658
/* This needs to be changed as it's not useful with big packets */
1557
1659
if (user && user[0])
1561
1663
1562
1664
/* We have to handle different version of handshake here */
1563
1665
#ifdef _CUSTOMCONFIG_
1564
#include "_cust_libmysql.h"
1666
#include "_cust_libdrizzle.h"
1565
1667
#endif
1566
1668
end= strend(end) + 1;
1567
1669
if (passwd[0])
1568
1670
{
1569
1671
{
1570
1672
*end++= SCRAMBLE_LENGTH;
1571
scramble(end, mysql->scramble, passwd);
1673
scramble(end, drizzle->scramble, passwd);
1572
1674
end+= SCRAMBLE_LENGTH;
1573
1675
}
1574
1676
}
1576
1678
*end++= '\0'; /* empty password */
1577
1679
1578
1680
/* Add database if needed */
1579
if (db && (mysql->server_capabilities & CLIENT_CONNECT_WITH_DB))
1681
if (db && (drizzle->server_capabilities & CLIENT_CONNECT_WITH_DB))
1580
1682
{
1581
1683
end= strmake(end, db, NAME_LEN) + 1;
1582
mysql->db= my_strdup(db,MYF(MY_WME));
1684
drizzle->db= my_strdup(db,MYF(MY_WME));
1583
1685
db= 0;
1584
1686
}
1585
1687
/* Write authentication package */
1586
1688
if (my_net_write(net, (uchar*) buff, (size_t) (end-buff)) || net_flush(net))
1587
1689
{
1588
set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
1690
set_drizzle_extended_error(drizzle, CR_SERVER_LOST, unknown_sqlstate,
1589
1691
ER(CR_SERVER_LOST_EXTENDED),
1590
1692
"sending authentication information",
1591
1693
errno);
1592
1694
goto error;
1593
1695
}
1594
1696
1595
1697
/*
1596
1698
Part 3: Authorization data's been sent. Now server can reply with
1597
1699
OK-packet, or re-request scrambled password.
1598
1700
*/
1599
1701
1600
if ((pkt_length=cli_safe_read(mysql)) == packet_error)
1702
if ((pkt_length=cli_safe_read(drizzle)) == packet_error)
1601
1703
{
1602
if (mysql->net.last_errno == CR_SERVER_LOST)
1603
set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
1704
if (drizzle->net.last_errno == CR_SERVER_LOST)
1705
set_drizzle_extended_error(drizzle, CR_SERVER_LOST, unknown_sqlstate,
1604
1706
ER(CR_SERVER_LOST_EXTENDED),
1605
1707
"reading authorization packet",
1606
1708
errno);
1607
1709
goto error;
1608
1710
}
1609
1711
1610
if (client_flag & CLIENT_COMPRESS) /* We will use compression */
1712
if (client_flag & CLIENT_COMPRESS) /* We will use compression */
1611
1713
net->compress=1;
1612
1714
1613
1715
1614
if (db && mysql_select_db(mysql, db))
1716
if (db && drizzle_select_db(drizzle, db))
1615
1717
{
1616
if (mysql->net.last_errno == CR_SERVER_LOST)
1617
set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
1718
if (drizzle->net.last_errno == CR_SERVER_LOST)
1719
set_drizzle_extended_error(drizzle, CR_SERVER_LOST, unknown_sqlstate,
1618
1720
ER(CR_SERVER_LOST_EXTENDED),
1619
1721
"Setting intital database",
1620
1722
errno);
1621
1723
goto error;
1622
1724
}
1623
1725
1624
if (mysql->options.init_commands)
1726
if (drizzle->options.init_commands)
1625
1727
{
1626
DYNAMIC_ARRAY *init_commands= mysql->options.init_commands;
1728
DYNAMIC_ARRAY *init_commands= drizzle->options.init_commands;
1627
1729
char **ptr= (char**)init_commands->buffer;
1628
1730
char **end_command= ptr + init_commands->elements;
1629
1731
1630
my_bool reconnect=mysql->reconnect;
1631
mysql->reconnect=0;
1732
my_bool reconnect=drizzle->reconnect;
1733
drizzle->reconnect=0;
1632
1734
1633
1735
for (; ptr < end_command; ptr++)
1634
1736
{
1635
MYSQL_RES *res;
1636
if (mysql_real_query(mysql,*ptr, (ulong) strlen(*ptr)))
1637
goto error;
1638
if (mysql->fields)
1737
DRIZZLE_RES *res;
1738
if (drizzle_real_query(drizzle,*ptr, (ulong) strlen(*ptr)))
1739
goto error;
1740
if (drizzle->fields)
1639
1741
{
1640
if (!(res= cli_use_result(mysql)))
1641
goto error;
1642
mysql_free_result(res);
1742
if (!(res= cli_use_result(drizzle)))
1743
goto error;
1744
drizzle_free_result(res);
1643
1745
}
1644
1746
}
1645
mysql->reconnect=reconnect;
1747
drizzle->reconnect=reconnect;
1646
1748
}
1647
1749
1648
reset_sigpipe(mysql);
1649
return(mysql);
1750
reset_sigpipe(drizzle);
1751
return(drizzle);
1650
1752
1651
1753
error:
1652
reset_sigpipe(mysql);
1754
reset_sigpipe(drizzle);
1653
1755
{
1654
1756
/* Free alloced memory */
1655
end_server(mysql);
1656
mysql_close_free(mysql);
1757
end_server(drizzle);
1758
drizzle_close_free(drizzle);
1657
1759
if (!(((ulong) client_flag) & CLIENT_REMEMBER_OPTIONS))
1658
mysql_close_free_options(mysql);
1760
drizzle_close_free_options(drizzle);
1659
1761
}
1660
1762
return(0);
1661
1763
}
1662
1764
1663
1765
1664
my_bool mysql_reconnect(MYSQL *mysql)
1766
my_bool drizzle_reconnect(DRIZZLE *drizzle)
1665
1767
{
1666
MYSQL tmp_mysql;
1667
assert(mysql);
1768
DRIZZLE tmp_drizzle;
1769
assert(drizzle);
1668
1770
1669
if (!mysql->reconnect ||
1670
(mysql->server_status & SERVER_STATUS_IN_TRANS) || !mysql->host_info)
1771
if (!drizzle->reconnect ||
1772
(drizzle->server_status & SERVER_STATUS_IN_TRANS) || !drizzle->host_info)
1671
1773
{
1672
1774
/* Allow reconnect next time */
1673
mysql->server_status&= ~SERVER_STATUS_IN_TRANS;
1674
set_mysql_error(mysql, CR_SERVER_GONE_ERROR, unknown_sqlstate);
1675
return(1);
1676
}
1677
mysql_init(&tmp_mysql);
1678
tmp_mysql.options= mysql->options;
1679
tmp_mysql.options.my_cnf_file= tmp_mysql.options.my_cnf_group= 0;
1680
1681
if (!mysql_real_connect(&tmp_mysql,mysql->host,mysql->user,mysql->passwd,
1682
mysql->db, mysql->port, mysql->unix_socket,
1683
mysql->client_flag | CLIENT_REMEMBER_OPTIONS))
1684
{
1685
mysql->net.last_errno= tmp_mysql.net.last_errno;
1686
strmov(mysql->net.last_error, tmp_mysql.net.last_error);
1687
strmov(mysql->net.sqlstate, tmp_mysql.net.sqlstate);
1688
return(1);
1689
}
1690
if (mysql_set_character_set(&tmp_mysql, mysql->charset->csname))
1691
{
1692
bzero((char*) &tmp_mysql.options,sizeof(tmp_mysql.options));
1693
mysql_close(&tmp_mysql);
1694
mysql->net.last_errno= tmp_mysql.net.last_errno;
1695
strmov(mysql->net.last_error, tmp_mysql.net.last_error);
1696
strmov(mysql->net.sqlstate, tmp_mysql.net.sqlstate);
1697
return(1);
1698
}
1699
1700
tmp_mysql.reconnect= 1;
1701
tmp_mysql.free_me= mysql->free_me;
1702
1703
/* Don't free options as these are now used in tmp_mysql */
1704
bzero((char*) &mysql->options,sizeof(mysql->options));
1705
mysql->free_me=0;
1706
mysql_close(mysql);
1707
*mysql=tmp_mysql;
1708
net_clear(&mysql->net, 1);
1709
mysql->affected_rows= ~(uint64_t) 0;
1775
drizzle->server_status&= ~SERVER_STATUS_IN_TRANS;
1776
set_drizzle_error(drizzle, CR_SERVER_GONE_ERROR, unknown_sqlstate);
1777
return(1);
1778
}
1779
drizzle_create(&tmp_drizzle);
1780
tmp_drizzle.options= drizzle->options;
1781
tmp_drizzle.options.my_cnf_file= tmp_drizzle.options.my_cnf_group= 0;
1782
1783
if (!drizzle_connect(&tmp_drizzle,drizzle->host,drizzle->user,drizzle->passwd,
1784
drizzle->db, drizzle->port, drizzle->unix_socket,
1785
drizzle->client_flag | CLIENT_REMEMBER_OPTIONS))
1786
{
1787
drizzle->net.last_errno= tmp_drizzle.net.last_errno;
1788
strmov(drizzle->net.last_error, tmp_drizzle.net.last_error);
1789
strmov(drizzle->net.sqlstate, tmp_drizzle.net.sqlstate);
1790
return(1);
1791
}
1792
if (drizzle_set_character_set(&tmp_drizzle, drizzle->charset->csname))
1793
{
1794
bzero((char*) &tmp_drizzle.options,sizeof(tmp_drizzle.options));
1795
drizzle_close(&tmp_drizzle);
1796
drizzle->net.last_errno= tmp_drizzle.net.last_errno;
1797
strmov(drizzle->net.last_error, tmp_drizzle.net.last_error);
1798
strmov(drizzle->net.sqlstate, tmp_drizzle.net.sqlstate);
1799
return(1);
1800
}
1801
1802
tmp_drizzle.reconnect= 1;
1803
tmp_drizzle.free_me= drizzle->free_me;
1804
1805
/* Don't free options as these are now used in tmp_drizzle */
1806
bzero((char*) &drizzle->options,sizeof(drizzle->options));
1807
drizzle->free_me=0;
1808
drizzle_close(drizzle);
1809
*drizzle=tmp_drizzle;
1810
net_clear(&drizzle->net, 1);
1811
drizzle->affected_rows= ~(uint64_t) 0;
1710
1812
return(0);
1711
1813
}
1712
1814
1716
1818
**************************************************************************/
1717
1819
1718
1820
int STDCALL
1719
mysql_select_db(MYSQL *mysql, const char *db)
1821
drizzle_select_db(DRIZZLE *drizzle, const char *db)
1720
1822
{
1721
1823
int error;
1722
1824
1723
if ((error=simple_command(mysql,COM_INIT_DB, (const uchar*) db,
1825
if ((error=simple_command(drizzle,COM_INIT_DB, (const uchar*) db,
1724
1826
(ulong) strlen(db),0)))
1725
1827
return(error);
1726
my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
1727
mysql->db=my_strdup(db,MYF(MY_WME));
1828
my_free(drizzle->db,MYF(MY_ALLOW_ZERO_PTR));
1829
drizzle->db=my_strdup(db,MYF(MY_WME));
1728
1830
return(0);
1729
1831
}
1730
1832
1731
1833
1732
1834
/*************************************************************************
1733
1835
Send a QUIT to the server and close the connection
1734
If handle is alloced by mysql connect free it.
1836
If handle is alloced by DRIZZLE connect free it.
1735
1837
*************************************************************************/
1736
1838
1737
static void mysql_close_free_options(MYSQL *mysql)
1839
static void drizzle_close_free_options(DRIZZLE *drizzle)
1738
1840
{
1739
my_free(mysql->options.user,MYF(MY_ALLOW_ZERO_PTR));
1740
my_free(mysql->options.host,MYF(MY_ALLOW_ZERO_PTR));
1741
my_free(mysql->options.password,MYF(MY_ALLOW_ZERO_PTR));
1742
my_free(mysql->options.unix_socket,MYF(MY_ALLOW_ZERO_PTR));
1743
my_free(mysql->options.db,MYF(MY_ALLOW_ZERO_PTR));
1744
my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
1745
my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
1746
my_free(mysql->options.charset_dir,MYF(MY_ALLOW_ZERO_PTR));
1747
my_free(mysql->options.charset_name,MYF(MY_ALLOW_ZERO_PTR));
1748
my_free(mysql->options.client_ip,MYF(MY_ALLOW_ZERO_PTR));
1749
if (mysql->options.init_commands)
1841
my_free(drizzle->options.user,MYF(MY_ALLOW_ZERO_PTR));
1842
my_free(drizzle->options.host,MYF(MY_ALLOW_ZERO_PTR));
1843
my_free(drizzle->options.password,MYF(MY_ALLOW_ZERO_PTR));
1844
my_free(drizzle->options.unix_socket,MYF(MY_ALLOW_ZERO_PTR));
1845
my_free(drizzle->options.db,MYF(MY_ALLOW_ZERO_PTR));
1846
my_free(drizzle->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
1847
my_free(drizzle->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
1848
my_free(drizzle->options.charset_dir,MYF(MY_ALLOW_ZERO_PTR));
1849
my_free(drizzle->options.charset_name,MYF(MY_ALLOW_ZERO_PTR));
1850
my_free(drizzle->options.client_ip,MYF(MY_ALLOW_ZERO_PTR));
1851
if (drizzle->options.init_commands)
1750
1852
{
1751
DYNAMIC_ARRAY *init_commands= mysql->options.init_commands;
1853
DYNAMIC_ARRAY *init_commands= drizzle->options.init_commands;
1752
1854
char **ptr= (char**)init_commands->buffer;
1753
1855
char **end= ptr + init_commands->elements;
1754
1856
for (; ptr<end; ptr++)
1757
1859
my_free((char*)init_commands,MYF(MY_WME));
1758
1860
}
1759
1861
#ifdef HAVE_SMEM
1760
if (mysql->options.shared_memory_base_name != def_shared_memory_base_name)
1761
my_free(mysql->options.shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
1862
if (drizzle->options.shared_memory_base_name != def_shared_memory_base_name)
1863
my_free(drizzle->options.shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
1762
1864
#endif /* HAVE_SMEM */
1763
bzero((char*) &mysql->options,sizeof(mysql->options));
1865
bzero((char*) &drizzle->options,sizeof(drizzle->options));
1764
1866
return;
1765
1867
}
1766
1868
1767
1869
1768
static void mysql_close_free(MYSQL *mysql)
1870
static void drizzle_close_free(DRIZZLE *drizzle)
1769
1871
{
1770
my_free((uchar*) mysql->host_info,MYF(MY_ALLOW_ZERO_PTR));
1771
my_free(mysql->user,MYF(MY_ALLOW_ZERO_PTR));
1772
my_free(mysql->passwd,MYF(MY_ALLOW_ZERO_PTR));
1773
my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
1774
my_free(mysql->info_buffer,MYF(MY_ALLOW_ZERO_PTR));
1775
mysql->info_buffer= 0;
1872
my_free((uchar*) drizzle->host_info,MYF(MY_ALLOW_ZERO_PTR));
1873
my_free(drizzle->user,MYF(MY_ALLOW_ZERO_PTR));
1874
my_free(drizzle->passwd,MYF(MY_ALLOW_ZERO_PTR));
1875
my_free(drizzle->db,MYF(MY_ALLOW_ZERO_PTR));
1876
my_free(drizzle->info_buffer,MYF(MY_ALLOW_ZERO_PTR));
1877
drizzle->info_buffer= 0;
1776
1878
1777
1879
/* Clear pointers for better safety */
1778
mysql->host_info= mysql->user= mysql->passwd= mysql->db= 0;
1880
drizzle->host_info= drizzle->user= drizzle->passwd= drizzle->db= 0;
1779
1881
}
1780
1882
1781
1883
1782
void STDCALL mysql_close(MYSQL *mysql)
1884
void STDCALL drizzle_close(DRIZZLE *drizzle)
1783
1885
{
1784
if (mysql) /* Some simple safety */
1886
if (drizzle) /* Some simple safety */
1785
1887
{
1786
1888
/* If connection is still up, send a QUIT message */
1787
if (mysql->net.vio != 0)
1889
if (drizzle->net.vio != 0)
1788
1890
{
1789
free_old_query(mysql);
1790
mysql->status=MYSQL_STATUS_READY; /* Force command */
1791
mysql->reconnect=0;
1792
simple_command(mysql,COM_QUIT,(uchar*) 0,0,1);
1793
end_server(mysql); /* Sets mysql->net.vio= 0 */
1891
free_old_query(drizzle);
1892
drizzle->status=DRIZZLE_STATUS_READY; /* Force command */
1893
drizzle->reconnect=0;
1894
simple_command(drizzle,COM_QUIT,(uchar*) 0,0,1);
1895
end_server(drizzle); /* Sets drizzle->net.vio= 0 */
1794
1896
}
1795
mysql_close_free_options(mysql);
1796
mysql_close_free(mysql);
1797
if (mysql->free_me)
1798
my_free((uchar*) mysql,MYF(0));
1897
drizzle_close_free_options(drizzle);
1898
drizzle_close_free(drizzle);
1899
if (drizzle->free_me)
1900
my_free((uchar*) drizzle,MYF(0));
1799
1901
}
1800
1902
return;
1801
1903
}
1802
1904
1803
1905
1804
static bool cli_read_query_result(MYSQL *mysql)
1906
static bool cli_read_query_result(DRIZZLE *drizzle)
1805
1907
{
1806
1908
uchar *pos;
1807
1909
ulong field_count;
1808
MYSQL_DATA *fields;
1910
DRIZZLE_DATA *fields;
1809
1911
ulong length;
1810
1912
1811
if ((length = cli_safe_read(mysql)) == packet_error)
1913
if ((length = cli_safe_read(drizzle)) == packet_error)
1812
1914
return(1);
1813
free_old_query(mysql); /* Free old result */
1814
#ifdef MYSQL_CLIENT /* Avoid warn of unused labels*/
1915
free_old_query(drizzle); /* Free old result */
1916
#ifdef MYSQL_CLIENT /* Avoid warn of unused labels*/
1815
1917
get_info:
1816
1918
#endif
1817
pos=(uchar*) mysql->net.read_pos;
1919
pos=(uchar*) drizzle->net.read_pos;
1818
1920
if ((field_count= net_field_length(&pos)) == 0)
1819
1921
{
1820
mysql->affected_rows= net_field_length_ll(&pos);
1821
mysql->insert_id= net_field_length_ll(&pos);
1822
if (protocol_41(mysql))
1823
{
1824
mysql->server_status=uint2korr(pos); pos+=2;
1825
mysql->warning_count=uint2korr(pos); pos+=2;
1826
}
1827
else if (mysql->server_capabilities & CLIENT_TRANSACTIONS)
1828
{
1829
/* MySQL 4.0 protocol */
1830
mysql->server_status=uint2korr(pos); pos+=2;
1831
mysql->warning_count= 0;
1832
}
1833
if (pos < mysql->net.read_pos+length && net_field_length(&pos))
1834
mysql->info=(char*) pos;
1922
drizzle->affected_rows= net_field_length_ll(&pos);
1923
drizzle->insert_id= net_field_length_ll(&pos);
1924
if (protocol_41(drizzle))
1925
{
1926
drizzle->server_status=uint2korr(pos); pos+=2;
1927
drizzle->warning_count=uint2korr(pos); pos+=2;
1928
}
1929
else if (drizzle->server_capabilities & CLIENT_TRANSACTIONS)
1930
{
1931
/* DRIZZLE 4.0 protocol */
1932
drizzle->server_status=uint2korr(pos); pos+=2;
1933
drizzle->warning_count= 0;
1934
}
1935
if (pos < drizzle->net.read_pos+length && net_field_length(&pos))
1936
drizzle->info=(char*) pos;
1835
1937
return(0);
1836
1938
}
1837
1939
#ifdef MYSQL_CLIENT
1838
if (field_count == NULL_LENGTH) /* LOAD DATA LOCAL INFILE */
1940
if (field_count == NULL_LENGTH) /* LOAD DATA LOCAL INFILE */
1839
1941
{
1840
1942
int error;
1841
1943
1842
if (!(mysql->options.client_flag & CLIENT_LOCAL_FILES))
1944
if (!(drizzle->options.client_flag & CLIENT_LOCAL_FILES))
1843
1945
{
1844
set_mysql_error(mysql, CR_MALFORMED_PACKET, unknown_sqlstate);
1946
set_drizzle_error(drizzle, CR_MALFORMED_PACKET, unknown_sqlstate);
1845
1947
return(1);
1846
}
1948
}
1847
1949
1848
error= handle_local_infile(mysql,(char*) pos);
1849
if ((length= cli_safe_read(mysql)) == packet_error || error)
1950
error= handle_local_infile(drizzle,(char*) pos);
1951
if ((length= cli_safe_read(drizzle)) == packet_error || error)
1850
1952
return(1);
1851
goto get_info; /* Get info packet */
1953
goto get_info; /* Get info packet */
1852
1954
}
1853
1955
#endif
1854
if (!(mysql->server_status & SERVER_STATUS_AUTOCOMMIT))
1855
mysql->server_status|= SERVER_STATUS_IN_TRANS;
1956
if (!(drizzle->server_status & SERVER_STATUS_AUTOCOMMIT))
1957
drizzle->server_status|= SERVER_STATUS_IN_TRANS;
1856
1958
1857
if (!(fields=cli_read_rows(mysql,(MYSQL_FIELD*)0, protocol_41(mysql) ? 7:5)))
1858
return(1);
1859
if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,
1860
(uint) field_count,0,
1861
mysql->server_capabilities)))
1862
return(1);
1863
mysql->status= MYSQL_STATUS_GET_RESULT;
1864
mysql->field_count= (uint) field_count;
1959
if (!(fields=cli_read_rows(drizzle,(DRIZZLE_FIELD*)0, protocol_41(drizzle) ? 7:5)))
1960
return(1);
1961
if (!(drizzle->fields=unpack_fields(fields,&drizzle->field_alloc,
1962
(uint) field_count,0,
1963
drizzle->server_capabilities)))
1964
return(1);
1965
drizzle->status= DRIZZLE_STATUS_GET_RESULT;
1966
drizzle->field_count= (uint) field_count;
1865
1967
return(0);
1866
1968
}
1867
1969
1868
1970
1869
1971
/*
1870
1972
Send the query and return so we can do something else.
1871
Needs to be followed by mysql_read_query_result() when we want to
1973
Needs to be followed by drizzle_read_query_result() when we want to
1872
1974
finish processing it.
1873
1975
*/
1874
1976
1875
1977
int32_t STDCALL
1876
mysql_send_query(MYSQL* mysql, const char* query, uint32_t length)
1978
drizzle_send_query(DRIZZLE *drizzle, const char* query, uint32_t length)
1877
1979
{
1878
return(simple_command(mysql, COM_QUERY, (uchar*) query, length, 1));
1980
return(simple_command(drizzle, COM_QUERY, (uchar*) query, length, 1));
1879
1981
}
1880
1982
1881
1983
1882
1984
int32_t STDCALL
1883
mysql_real_query(MYSQL *mysql, const char *query, uint32_t length)
1985
drizzle_real_query(DRIZZLE *drizzle, const char *query, uint32_t length)
1884
1986
{
1885
if (mysql_send_query(mysql,query,length))
1987
if (drizzle_send_query(drizzle,query,length))
1886
1988
return(1);
1887
return((int) (*mysql->methods->read_query_result)(mysql));
1989
return((int) (*drizzle->methods->read_query_result)(drizzle));
1888
1990
}
1889
1991
1890
1992
1891
1993
/**************************************************************************
1892
1994
Alloc result struct for buffered results. All rows are read to buffer.
1893
mysql_data_seek may be used.
1995
drizzle_data_seek may be used.
1894
1996
**************************************************************************/
1895
1997
1896
MYSQL_RES * STDCALL mysql_store_result(MYSQL *mysql)
1998
DRIZZLE_RES * STDCALL drizzle_store_result(DRIZZLE *drizzle)
1897
1999
{
1898
MYSQL_RES *result;
2000
DRIZZLE_RES *result;
1899
2001
1900
if (!mysql->fields)
1901
return(0);
1902
if (mysql->status != MYSQL_STATUS_GET_RESULT)
1903
{
1904
set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
1905
return(0);
1906
}
1907
mysql->status=MYSQL_STATUS_READY; /* server is ready */
1908
if (!(result=(MYSQL_RES*) my_malloc((uint) (sizeof(MYSQL_RES)+
1909
sizeof(ulong) *
1910
mysql->field_count),
1911
MYF(MY_WME | MY_ZEROFILL))))
1912
{
1913
set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
1914
return(0);
1915
}
1916
result->methods= mysql->methods;
1917
result->eof= 1; /* Marker for buffered */
2002
if (!drizzle->fields)
2003
return(0);
2004
if (drizzle->status != DRIZZLE_STATUS_GET_RESULT)
2005
{
2006
set_drizzle_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
2007
return(0);
2008
}
2009
drizzle->status=DRIZZLE_STATUS_READY; /* server is ready */
2010
if (!(result=(DRIZZLE_RES*) my_malloc((uint) (sizeof(DRIZZLE_RES)+
2011
sizeof(ulong) *
2012
drizzle->field_count),
2013
MYF(MY_WME | MY_ZEROFILL))))
2014
{
2015
set_drizzle_error(drizzle, CR_OUT_OF_MEMORY, unknown_sqlstate);
2016
return(0);
2017
}
2018
result->methods= drizzle->methods;
2019
result->eof= 1; /* Marker for buffered */
1918
2020
result->lengths= (uint32_t*) (result+1);
1919
2021
if (!(result->data=
1920
(*mysql->methods->read_rows)(mysql,mysql->fields,mysql->field_count)))
2022
(*drizzle->methods->read_rows)(drizzle,drizzle->fields,drizzle->field_count)))
1921
2023
{
1922
2024
my_free((uchar*) result,MYF(0));
1923
2025
return(0);
1924
2026
}
1925
mysql->affected_rows= result->row_count= result->data->rows;
1926
result->data_cursor= result->data->data;
1927
result->fields= mysql->fields;
1928
result->field_alloc= mysql->field_alloc;
1929
result->field_count= mysql->field_count;
2027
drizzle->affected_rows= result->row_count= result->data->rows;
2028
result->data_cursor= result->data->data;
2029
result->fields= drizzle->fields;
2030
result->field_alloc= drizzle->field_alloc;
2031
result->field_count= drizzle->field_count;
1930
2032
/* The rest of result members is bzeroed in malloc */
1931
mysql->fields=0; /* fields is now in result */
1932
clear_alloc_root(&mysql->field_alloc);
1933
/* just in case this was mistakenly called after mysql_stmt_execute() */
1934
mysql->unbuffered_fetch_owner= 0;
1935
return(result); /* Data fetched */
2033
drizzle->fields=0; /* fields is now in result */
2034
clear_alloc_root(&drizzle->field_alloc);
2035
/* just in case this was mistakenly called after drizzle_stmt_execute() */
2036
drizzle->unbuffered_fetch_owner= 0;
2037
return(result); /* Data fetched */
1936
2038
}
1937
2039
1938
2040
1939
2041
/**************************************************************************
1940
2042
Alloc struct for use with unbuffered reads. Data is fetched by domand
1941
when calling to mysql_fetch_row.
1942
mysql_data_seek is a noop.
2043
when calling to drizzle_fetch_row.
2044
DRIZZLE_DATA_seek is a noop.
1943
2045
1944
No other queries may be specified with the same MYSQL handle.
1945
There shouldn't be much processing per row because mysql server shouldn't
2046
No other queries may be specified with the same DRIZZLE handle.
2047
There shouldn't be much processing per row because DRIZZLE server shouldn't
1946
2048
have to wait for the client (and will not wait more than 30 sec/packet).
1947
2049
**************************************************************************/
1948
2050
1949
static MYSQL_RES * cli_use_result(MYSQL *mysql)
2051
static DRIZZLE_RES * cli_use_result(DRIZZLE *drizzle)
1950
2052
{
1951
MYSQL_RES *result;
2053
DRIZZLE_RES *result;
1952
2054
1953
if (!mysql->fields)
2055
if (!drizzle->fields)
1954
2056
return(0);
1955
if (mysql->status != MYSQL_STATUS_GET_RESULT)
2057
if (drizzle->status != DRIZZLE_STATUS_GET_RESULT)
1956
2058
{
1957
set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
2059
set_drizzle_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
1958
2060
return(0);
1959
2061
}
1960
if (!(result=(MYSQL_RES*) my_malloc(sizeof(*result)+
1961
sizeof(ulong)*mysql->field_count,
1962
MYF(MY_WME | MY_ZEROFILL))))
2062
if (!(result=(DRIZZLE_RES*) my_malloc(sizeof(*result)+
2063
sizeof(ulong)*drizzle->field_count,
2064
MYF(MY_WME | MY_ZEROFILL))))
1963
2065
return(0);
1964
2066
result->lengths=(uint32_t*) (result+1);
1965
result->methods= mysql->methods;
1966
if (!(result->row=(MYSQL_ROW)
1967
my_malloc(sizeof(result->row[0])*(mysql->field_count+1), MYF(MY_WME))))
1968
{ /* Ptrs: to one row */
2067
result->methods= drizzle->methods;
2068
if (!(result->row=(DRIZZLE_ROW)
2069
my_malloc(sizeof(result->row[0])*(drizzle->field_count+1), MYF(MY_WME))))
2070
{ /* Ptrs: to one row */
1969
2071
my_free((uchar*) result,MYF(0));
1970
2072
return(0);
1971
2073
}
1972
result->fields= mysql->fields;
1973
result->field_alloc= mysql->field_alloc;
1974
result->field_count= mysql->field_count;
2074
result->fields= drizzle->fields;
2075
result->field_alloc= drizzle->field_alloc;
2076
result->field_count= drizzle->field_count;
1975
2077
result->current_field=0;
1976
result->handle= mysql;
1977
result->current_row= 0;
1978
mysql->fields=0; /* fields is now in result */
1979
clear_alloc_root(&mysql->field_alloc);
1980
mysql->status=MYSQL_STATUS_USE_RESULT;
1981
mysql->unbuffered_fetch_owner= &result->unbuffered_fetch_cancelled;
1982
return(result); /* Data is read to be fetched */
2078
result->handle= drizzle;
2079
result->current_row= 0;
2080
drizzle->fields=0; /* fields is now in result */
2081
clear_alloc_root(&drizzle->field_alloc);
2082
drizzle->status=DRIZZLE_STATUS_USE_RESULT;
2083
drizzle->unbuffered_fetch_owner= &result->unbuffered_fetch_cancelled;
2084
return(result); /* Data is read to be fetched */
1983
2085
}
1984
2086
1985
2087
1987
2089
Return next row of the query results
1988
2090
**************************************************************************/
1989
2091
1990
MYSQL_ROW STDCALL
1991
mysql_fetch_row(MYSQL_RES *res)
2092
DRIZZLE_ROW STDCALL
2093
drizzle_fetch_row(DRIZZLE_RES *res)
1992
2094
{
1993
2095
if (!res->data)
1994
{ /* Unbufferred fetch */
2096
{ /* Unbufferred fetch */
1995
2097
if (!res->eof)
1996
2098
{
1997
MYSQL *mysql= res->handle;
1998
if (mysql->status != MYSQL_STATUS_USE_RESULT)
2099
DRIZZLE *drizzle= res->handle;
2100
if (drizzle->status != DRIZZLE_STATUS_USE_RESULT)
1999
2101
{
2000
set_mysql_error(mysql,
2001
res->unbuffered_fetch_cancelled ?
2102
set_drizzle_error(drizzle,
2103
res->unbuffered_fetch_cancelled ?
2002
2104
CR_FETCH_CANCELED : CR_COMMANDS_OUT_OF_SYNC,
2003
2105
unknown_sqlstate);
2004
2106
}
2005
else if (!(read_one_row(mysql, res->field_count, res->row, res->lengths)))
2107
else if (!(read_one_row(drizzle, res->field_count, res->row, res->lengths)))
2006
2108
{
2007
res->row_count++;
2008
return(res->current_row=res->row);
2109
res->row_count++;
2110
return(res->current_row=res->row);
2009
2111
}
2010
2112
res->eof=1;
2011
mysql->status=MYSQL_STATUS_READY;
2113
drizzle->status=DRIZZLE_STATUS_READY;
2012
2114
/*
2013
2115
Reset only if owner points to us: there is a chance that somebody
2014
started new query after mysql_stmt_close():
2116
started new query after drizzle_stmt_close():
2015
2117
*/
2016
if (mysql->unbuffered_fetch_owner == &res->unbuffered_fetch_cancelled)
2017
mysql->unbuffered_fetch_owner= 0;
2018
/* Don't clear handle in mysql_free_result */
2118
if (drizzle->unbuffered_fetch_owner == &res->unbuffered_fetch_cancelled)
2119
drizzle->unbuffered_fetch_owner= 0;
2120
/* Don't clear handle in drizzle_free_result */
2019
2121
res->handle=0;
2020
2122
}
2021
return((MYSQL_ROW) NULL);
2123
return((DRIZZLE_ROW) NULL);
2022
2124
}
2023
2125
{
2024
MYSQL_ROW tmp;
2126
DRIZZLE_ROW tmp;
2025
2127
if (!res->data_cursor)
2026
2128
{
2027
return(res->current_row=(MYSQL_ROW) NULL);
2129
return(res->current_row=(DRIZZLE_ROW) NULL);
2028
2130
}
2029
2131
tmp = res->data_cursor->data;
2030
2132
res->data_cursor = res->data_cursor->next;
2035
2137
2036
2138
/**************************************************************************
2037
2139
Get column lengths of the current row
2038
If one uses mysql_use_result, res->lengths contains the length information,
2140
If one uses drizzle_use_result, res->lengths contains the length information,
2039
2141
else the lengths are calculated from the offset between pointers.
2040
2142
**************************************************************************/
2041
2143
2042
2144
uint32_t * STDCALL
2043
mysql_fetch_lengths(MYSQL_RES *res)
2145
drizzle_fetch_lengths(DRIZZLE_RES *res)
2044
2146
{
2045
MYSQL_ROW column;
2147
DRIZZLE_ROW column;
2046
2148
2047
2149
if (!(column=res->current_row))
2048
return 0; /* Something is wrong */
2150
return 0; /* Something is wrong */
2049
2151
if (res->data)
2050
2152
(*res->methods->fetch_lengths)(res->lengths, column, res->field_count);
2051
2153
return res->lengths;
2053
2155
2054
2156
2055
2157
int STDCALL
2056
mysql_options(MYSQL *mysql,enum mysql_option option, const void *arg)
2158
drizzle_options(DRIZZLE *drizzle,enum drizzle_option option, const void *arg)
2057
2159
{
2058
2160
switch (option) {
2059
case MYSQL_OPT_CONNECT_TIMEOUT:
2060
mysql->options.connect_timeout= *(uint*) arg;
2061
break;
2062
case MYSQL_OPT_READ_TIMEOUT:
2063
mysql->options.read_timeout= *(uint*) arg;
2064
break;
2065
case MYSQL_OPT_WRITE_TIMEOUT:
2066
mysql->options.write_timeout= *(uint*) arg;
2067
break;
2068
case MYSQL_OPT_COMPRESS:
2069
mysql->options.compress= 1; /* Remember for connect */
2070
mysql->options.client_flag|= CLIENT_COMPRESS;
2071
break;
2072
case MYSQL_OPT_NAMED_PIPE: /* This option is depricated */
2073
mysql->options.protocol=MYSQL_PROTOCOL_PIPE; /* Force named pipe */
2074
break;
2075
case MYSQL_OPT_LOCAL_INFILE: /* Allow LOAD DATA LOCAL ?*/
2161
case DRIZZLE_OPT_CONNECT_TIMEOUT:
2162
drizzle->options.connect_timeout= *(uint*) arg;
2163
break;
2164
case DRIZZLE_OPT_READ_TIMEOUT:
2165
drizzle->options.read_timeout= *(uint*) arg;
2166
break;
2167
case DRIZZLE_OPT_WRITE_TIMEOUT:
2168
drizzle->options.write_timeout= *(uint*) arg;
2169
break;
2170
case DRIZZLE_OPT_COMPRESS:
2171
drizzle->options.compress= 1; /* Remember for connect */
2172
drizzle->options.client_flag|= CLIENT_COMPRESS;
2173
break;
2174
case DRIZZLE_OPT_NAMED_PIPE: /* This option is depricated */
2175
drizzle->options.protocol=DRIZZLE_PROTOCOL_PIPE; /* Force named pipe */
2176
break;
2177
case DRIZZLE_OPT_LOCAL_INFILE: /* Allow LOAD DATA LOCAL ?*/
2076
2178
if (!arg || test(*(uint*) arg))
2077
mysql->options.client_flag|= CLIENT_LOCAL_FILES;
2179
drizzle->options.client_flag|= CLIENT_LOCAL_FILES;
2078
2180
else
2079
mysql->options.client_flag&= ~CLIENT_LOCAL_FILES;
2080
break;
2081
case MYSQL_INIT_COMMAND:
2082
add_init_command(&mysql->options,arg);
2083
break;
2084
case MYSQL_READ_DEFAULT_FILE:
2085
my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
2086
mysql->options.my_cnf_file=my_strdup(arg,MYF(MY_WME));
2087
break;
2088
case MYSQL_READ_DEFAULT_GROUP:
2089
my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
2090
mysql->options.my_cnf_group=my_strdup(arg,MYF(MY_WME));
2091
break;
2092
case MYSQL_SET_CHARSET_DIR:
2093
my_free(mysql->options.charset_dir,MYF(MY_ALLOW_ZERO_PTR));
2094
mysql->options.charset_dir=my_strdup(arg,MYF(MY_WME));
2095
break;
2096
case MYSQL_SET_CHARSET_NAME:
2097
my_free(mysql->options.charset_name,MYF(MY_ALLOW_ZERO_PTR));
2098
mysql->options.charset_name=my_strdup(arg,MYF(MY_WME));
2099
break;
2100
case MYSQL_OPT_PROTOCOL:
2101
mysql->options.protocol= *(uint*) arg;
2102
break;
2103
case MYSQL_SHARED_MEMORY_BASE_NAME:
2181
drizzle->options.client_flag&= ~CLIENT_LOCAL_FILES;
2182
break;
2183
case DRIZZLE_INIT_COMMAND:
2184
add_init_command(&drizzle->options,arg);
2185
break;
2186
case DRIZZLE_READ_DEFAULT_FILE:
2187
my_free(drizzle->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
2188
drizzle->options.my_cnf_file=my_strdup(arg,MYF(MY_WME));
2189
break;
2190
case DRIZZLE_READ_DEFAULT_GROUP:
2191
my_free(drizzle->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
2192
drizzle->options.my_cnf_group=my_strdup(arg,MYF(MY_WME));
2193
break;
2194
case DRIZZLE_SET_CHARSET_DIR:
2195
my_free(drizzle->options.charset_dir,MYF(MY_ALLOW_ZERO_PTR));
2196
drizzle->options.charset_dir=my_strdup(arg,MYF(MY_WME));
2197
break;
2198
case DRIZZLE_SET_CHARSET_NAME:
2199
my_free(drizzle->options.charset_name,MYF(MY_ALLOW_ZERO_PTR));
2200
drizzle->options.charset_name=my_strdup(arg,MYF(MY_WME));
2201
break;
2202
case DRIZZLE_OPT_PROTOCOL:
2203
drizzle->options.protocol= *(uint*) arg;
2204
break;
2205
case DRIZZLE_SHARED_MEMORY_BASE_NAME:
2104
2206
#ifdef HAVE_SMEM
2105
if (mysql->options.shared_memory_base_name != def_shared_memory_base_name)
2106
my_free(mysql->options.shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
2107
mysql->options.shared_memory_base_name=my_strdup(arg,MYF(MY_WME));
2207
if (drizzle->options.shared_memory_base_name != def_shared_memory_base_name)
2208
my_free(drizzle->options.shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
2209
drizzle->options.shared_memory_base_name=my_strdup(arg,MYF(MY_WME));
2108
2210
#endif
2109
2211
break;
2110
case MYSQL_OPT_USE_REMOTE_CONNECTION:
2111
case MYSQL_OPT_USE_EMBEDDED_CONNECTION:
2112
case MYSQL_OPT_GUESS_CONNECTION:
2113
mysql->options.methods_to_use= option;
2114
break;
2115
case MYSQL_SET_CLIENT_IP:
2116
mysql->options.client_ip= my_strdup(arg, MYF(MY_WME));
2117
break;
2118
case MYSQL_SECURE_AUTH:
2119
mysql->options.secure_auth= *(my_bool *) arg;
2120
break;
2121
case MYSQL_REPORT_DATA_TRUNCATION:
2122
mysql->options.report_data_truncation= test(*(my_bool *) arg);
2123
break;
2124
case MYSQL_OPT_RECONNECT:
2125
mysql->reconnect= *(my_bool *) arg;
2126
break;
2127
case MYSQL_OPT_SSL_VERIFY_SERVER_CERT:
2212
case DRIZZLE_OPT_USE_REMOTE_CONNECTION:
2213
case DRIZZLE_OPT_USE_EMBEDDED_CONNECTION:
2214
case DRIZZLE_OPT_GUESS_CONNECTION:
2215
drizzle->options.methods_to_use= option;
2216
break;
2217
case DRIZZLE_SET_CLIENT_IP:
2218
drizzle->options.client_ip= my_strdup(arg, MYF(MY_WME));
2219
break;
2220
case DRIZZLE_SECURE_AUTH:
2221
drizzle->options.secure_auth= *(my_bool *) arg;
2222
break;
2223
case DRIZZLE_REPORT_DATA_TRUNCATION:
2224
drizzle->options.report_data_truncation= test(*(my_bool *) arg);
2225
break;
2226
case DRIZZLE_OPT_RECONNECT:
2227
drizzle->reconnect= *(my_bool *) arg;
2228
break;
2229
case DRIZZLE_OPT_SSL_VERIFY_SERVER_CERT:
2128
2230
if (*(my_bool*) arg)
2129
mysql->options.client_flag|= CLIENT_SSL_VERIFY_SERVER_CERT;
2231
drizzle->options.client_flag|= CLIENT_SSL_VERIFY_SERVER_CERT;
2130
2232
else
2131
mysql->options.client_flag&= ~CLIENT_SSL_VERIFY_SERVER_CERT;
2233
drizzle->options.client_flag&= ~CLIENT_SSL_VERIFY_SERVER_CERT;
2132
2234
break;
2133
2235
default:
2134
2236
return(1);
2138
2240
2139
2241
2140
2242
/****************************************************************************
2141
Functions to get information from the MySQL structure
2243
Functions to get information from the DRIZZLE structure
2142
2244
These are functions to make shared libraries more usable.
2143
2245
****************************************************************************/
2144
2246
2145
/* MYSQL_RES */
2146
uint64_t STDCALL mysql_num_rows(MYSQL_RES *res)
2247
/* DRIZZLE_RES */
2248
uint64_t STDCALL drizzle_num_rows(DRIZZLE_RES *res)
2147
2249
{
2148
2250
return res->row_count;
2149
2251
}
2150
2252
2151
unsigned int STDCALL mysql_num_fields(MYSQL_RES *res)
2253
unsigned int STDCALL drizzle_num_fields(DRIZZLE_RES *res)
2152
2254
{
2153
2255
return res->field_count;
2154
2256
}
2155
2257
2156
uint STDCALL mysql_errno(MYSQL *mysql)
2258
uint STDCALL drizzle_errno(DRIZZLE *drizzle)
2157
2259
{
2158
return mysql ? mysql->net.last_errno : mysql_server_last_errno;
2260
return drizzle ? drizzle->net.last_errno : drizzle_server_last_errno;
2159
2261
}
2160
2262
2161
2263
2162
const char * STDCALL mysql_error(MYSQL *mysql)
2264
const char * STDCALL drizzle_error(DRIZZLE *drizzle)
2163
2265
{
2164
return mysql ? mysql->net.last_error : mysql_server_last_error;
2266
return drizzle ? drizzle->net.last_error : drizzle_server_last_error;
2165
2267
}
2166
2268
2167
2269
2169
2271
Get version number for server in a form easy to test on
2170
2272
2171
2273
SYNOPSIS
2172
mysql_get_server_version()
2173
mysql Connection
2274
drizzle_get_server_version()
2275
drizzle Connection
2174
2276
2175
2277
EXAMPLE
2176
2278
4.1.0-alfa -> 40100
2177
2279
2178
2280
NOTES
2179
2281
We will ensure that a newer server always has a bigger number.
2180
2282
2183
2285
*/
2184
2286
2185
2287
uint32_t STDCALL
2186
mysql_get_server_version(MYSQL *mysql)
2288
drizzle_get_server_version(DRIZZLE *drizzle)
2187
2289
{
2188
2290
uint major, minor, version;
2189
char *pos= mysql->server_version, *end_pos;
2190
major= (uint) strtoul(pos, &end_pos, 10); pos=end_pos+1;
2191
minor= (uint) strtoul(pos, &end_pos, 10); pos=end_pos+1;
2291
char *pos= drizzle->server_version, *end_pos;
2292
major= (uint) strtoul(pos, &end_pos, 10); pos=end_pos+1;
2293
minor= (uint) strtoul(pos, &end_pos, 10); pos=end_pos+1;
2192
2294
version= (uint) strtoul(pos, &end_pos, 10);
2193
2295
return (ulong) major*10000L+(ulong) (minor*100+version);
2194
2296
}
2195
2297
2196
2298
2197
/*
2198
mysql_set_character_set function sends SET NAMES cs_name to
2299
/*
2300
drizzle_set_character_set function sends SET NAMES cs_name to
2199
2301
the server (which changes character_set_client, character_set_result
2200
and character_set_connection) and updates mysql->charset so other
2201
functions like mysql_real_escape will work correctly.
2302
and character_set_connection) and updates drizzle->charset so other
2303
functions like drizzle_real_escape will work correctly.
2202
2304
*/
2203
int STDCALL mysql_set_character_set(MYSQL *mysql, const char *cs_name)
2305
int STDCALL drizzle_set_character_set(DRIZZLE *drizzle, const char *cs_name)
2204
2306
{
2205
2307
struct charset_info_st *cs;
2206
2308
const char *save_csdir= charsets_dir;
2207
2309
2208
if (mysql->options.charset_dir)
2209
charsets_dir= mysql->options.charset_dir;
2310
if (drizzle->options.charset_dir)
2311
charsets_dir= drizzle->options.charset_dir;
2210
2312
2211
2313
if (strlen(cs_name) < MY_CS_NAME_SIZE &&
2212
2314
(cs= get_charset_by_csname(cs_name, MY_CS_PRIMARY, MYF(0))))
2214
2316
char buff[MY_CS_NAME_SIZE + 10];
2215
2317
charsets_dir= save_csdir;
2216
2318
/* Skip execution of "SET NAMES" for pre-4.1 servers */
2217
if (mysql_get_server_version(mysql) < 40100)
2319
if (drizzle_get_server_version(drizzle) < 40100)
2218
2320
return 0;
2219
2321
sprintf(buff, "SET NAMES %s", cs_name);
2220
if (!mysql_real_query(mysql, buff, strlen(buff)))
2322
if (!drizzle_real_query(drizzle, buff, strlen(buff)))
2221
2323
{
2222
mysql->charset= cs;
2324
drizzle->charset= cs;
2223
2325
}
2224
2326
}
2225
2327
else
2226
2328
{
2227
2329
char cs_dir_name[FN_REFLEN];
2228
2330
get_charsets_dir(cs_dir_name);
2229
set_mysql_extended_error(mysql, CR_CANT_READ_CHARSET, unknown_sqlstate,
2331
set_drizzle_extended_error(drizzle, CR_CANT_READ_CHARSET, unknown_sqlstate,
2230
2332
ER(CR_CANT_READ_CHARSET), cs_name, cs_dir_name);
2231
2333
}
2232
2334
charsets_dir= save_csdir;
2233
return mysql->net.last_errno;
2335
return drizzle->net.last_errno;
2234
2336
}
2235
2337
2236
2338
Loggerhead is a web-based interface for Breezy
Version: 2.0.1