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