~drizzle-trunk/drizzle/development
» Revision
1812.3.1
: plugin/drizzle_protocol/drizzle_protocol.cc
« back to all changes in this revision
Viewing changes to plugin/drizzle_protocol/drizzle_protocol.cc
- browse files at revision 1812.3.1
- compare with another revision
- compare with revision 1958
- download diff
- download tarball
- view history from revision 1812.3.1
- Committer: Brian Aker
- Date: 2010-10-05 21:45:20 UTC
- mto: (1821.1.1 build) (1827.1.1 trunk-drizzle) (1820.1.1 build) (1822.1.2 build)
- mto: This revision was merged to the branch mainline in revision 1821.
- Revision ID: brian@tangent.org-20101005214520-xk0ac4eza3n56qoz
This patch encapsulates the MySQL protocol around the Drizzle port so that we have access even in the event of MySQL being installed and running.
- files removed:
- plugin/drizzle_protocol/net_serv.cc
- files renamed:
- plugin/drizzle_protocol/table_function.h => plugin/drizzle_protocol/status_table.h
- files modified:
- plugin/drizzle_protocol/drizzle_protocol.cc
added
removed
plugin/drizzle_protocol/drizzle_protocol.cc
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
*
4
* Copyright (C) 2008 Sun Microsystems
5
*
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; version 2 of the License.
9
*
10
* This program is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
* GNU General Public License for more details.
14
*
15
* You should have received a copy of the GNU General Public License
16
* along with this program; if not, write to the Free Software
17
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4
* Copyright (C) 2010 Brian Aker
5
*
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; either version 2 of the License, or
9
* (at your option) any later version.
10
*
11
* This program is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* GNU General Public License for more details.
15
*
16
* You should have received a copy of the GNU General Public License
17
* along with this program; if not, write to the Free Software
18
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
*/
19
20
21
20
22
#include "config.h"
21
23
#include <drizzled/gettext.h>
22
24
#include <drizzled/error.h>
29
31
#include <iostream>
30
32
#include <boost/program_options.hpp>
31
33
#include <drizzled/module/option_map.h>
32
#include "pack.h"
33
#include "errmsg.h"
34
34
#include "drizzle_protocol.h"
35
#include "options.h"
36
#include "table_function.h"
37
38
#define PROTOCOL_VERSION 10
35
#include "plugin/drizzle_protocol/status_table.h"
39
36
40
37
namespace po= boost::program_options;
41
38
using namespace drizzled;
44
41
namespace drizzle_protocol
45
42
{
46
43
47
48
static const uint32_t DRIZZLE_TCP_PORT= 4427;
49
static const unsigned int PACKET_BUFFER_EXTRA_ALLOC= 1024;
50
44
static uint32_t port;
51
45
static uint32_t connect_timeout;
52
46
static uint32_t read_timeout;
53
47
static uint32_t write_timeout;
54
48
static uint32_t retry_count;
55
49
static uint32_t buffer_length;
56
static char* bind_address= NULL;
50
static char* bind_address;
57
51
58
static plugin::TableFunction* drizzle_status_table_function_ptr= NULL;
52
static const uint32_t DRIZZLE_TCP_PORT= 4427;
59
53
60
54
ListenDrizzleProtocol::~ListenDrizzleProtocol()
61
55
{
70
64
71
65
in_port_t ListenDrizzleProtocol::getPort(void) const
72
66
{
73
char *env;
74
75
if (port == 0)
76
{
77
port= DRIZZLE_TCP_PORT;
78
79
if ((env = getenv("DRIZZLE_TCP_PORT")))
80
port= (uint32_t) atoi(env);
81
82
assert(port != 0);
83
}
84
85
67
return (in_port_t) port;
86
68
}
87
69
88
plugin::Client *ListenDrizzleProtocol::getClient(int fd)
89
{
90
int new_fd;
91
new_fd= acceptTcp(fd);
92
if (new_fd == -1)
93
return NULL;
94
95
return new (nothrow) ClientDrizzleProtocol(new_fd, using_mysql41_protocol);
96
}
97
98
drizzled::atomic<uint64_t> ClientDrizzleProtocol::connectionCount;
99
drizzled::atomic<uint64_t> ClientDrizzleProtocol::failedConnections;
100
drizzled::atomic<uint64_t> ClientDrizzleProtocol::connected;
101
102
ClientDrizzleProtocol::ClientDrizzleProtocol(int fd, bool using_mysql41_protocol_arg):
103
using_mysql41_protocol(using_mysql41_protocol_arg)
104
{
105
net.vio= 0;
106
107
if (fd == -1)
108
return;
109
110
if (drizzleclient_net_init_sock(&net, fd, 0, buffer_length))
111
throw bad_alloc();
112
113
drizzleclient_net_set_read_timeout(&net, read_timeout);
114
drizzleclient_net_set_write_timeout(&net, write_timeout);
115
net.retry_count=retry_count;
116
}
117
118
ClientDrizzleProtocol::~ClientDrizzleProtocol()
119
{
120
if (net.vio)
121
drizzleclient_vio_close(net.vio);
122
}
123
124
int ClientDrizzleProtocol::getFileDescriptor(void)
125
{
126
return drizzleclient_net_get_sd(&net);
127
}
128
129
bool ClientDrizzleProtocol::isConnected()
130
{
131
return net.vio != 0;
132
}
133
134
bool ClientDrizzleProtocol::isReading(void)
135
{
136
return net.reading_or_writing == 1;
137
}
138
139
bool ClientDrizzleProtocol::isWriting(void)
140
{
141
return net.reading_or_writing == 2;
142
}
143
144
bool ClientDrizzleProtocol::flush()
145
{
146
if (net.vio == NULL)
147
return false;
148
bool ret= drizzleclient_net_write(&net, (unsigned char*) packet.ptr(),
149
packet.length());
150
packet.length(0);
151
return ret;
152
}
153
154
void ClientDrizzleProtocol::close(void)
155
{
156
if (net.vio)
157
{
158
drizzleclient_net_close(&net);
159
drizzleclient_net_end(&net);
160
connected.decrement();
161
}
162
}
163
164
bool ClientDrizzleProtocol::authenticate()
165
{
166
bool connection_is_valid;
167
168
connectionCount.increment();
169
connected.increment();
170
171
/* Use "connect_timeout" value during connection phase */
172
drizzleclient_net_set_read_timeout(&net, connect_timeout);
173
drizzleclient_net_set_write_timeout(&net, connect_timeout);
174
175
connection_is_valid= checkConnection();
176
177
if (connection_is_valid)
178
sendOK();
179
else
180
{
181
sendError(session->main_da.sql_errno(), session->main_da.message());
182
failedConnections.increment();
183
return false;
184
}
185
186
/* Connect completed, set read/write timeouts back to default */
187
drizzleclient_net_set_read_timeout(&net, read_timeout);
188
drizzleclient_net_set_write_timeout(&net, write_timeout);
189
return true;
190
}
191
192
bool ClientDrizzleProtocol::readCommand(char **l_packet, uint32_t *packet_length)
193
{
194
/*
195
This thread will do a blocking read from the client which
196
will be interrupted when the next command is received from
197
the client, the connection is closed or "net_wait_timeout"
198
number of seconds has passed
199
*/
200
#ifdef NEVER
201
/* We can do this much more efficiently with poll timeouts or watcher thread,
202
disabling for now, which means net_wait_timeout == read_timeout. */
203
drizzleclient_net_set_read_timeout(&net,
204
session->variables.net_wait_timeout);
205
#endif
206
207
net.pkt_nr=0;
208
209
*packet_length= drizzleclient_net_read(&net);
210
if (*packet_length == packet_error)
211
{
212
/* Check if we can continue without closing the connection */
213
214
if(net.last_errno== CR_NET_PACKET_TOO_LARGE)
215
my_error(ER_NET_PACKET_TOO_LARGE, MYF(0));
216
if (session->main_da.status() == Diagnostics_area::DA_ERROR)
217
sendError(session->main_da.sql_errno(), session->main_da.message());
218
else
219
sendOK();
220
221
if (net.error != 3)
222
return false; // We have to close it.
223
224
net.error= 0;
225
*packet_length= 0;
226
return true;
227
}
228
229
*l_packet= (char*) net.read_pos;
230
231
/*
232
'packet_length' contains length of data, as it was stored in packet
233
header. In case of malformed header, drizzleclient_net_read returns zero.
234
If packet_length is not zero, drizzleclient_net_read ensures that the returned
235
number of bytes was actually read from network.
236
There is also an extra safety measure in drizzleclient_net_read:
237
it sets packet[packet_length]= 0, but only for non-zero packets.
238
*/
239
240
if (*packet_length == 0) /* safety */
241
{
242
/* Initialize with COM_SLEEP packet */
243
(*l_packet)[0]= (unsigned char) COM_SLEEP;
244
*packet_length= 1;
245
}
246
else if (using_mysql41_protocol)
247
{
248
/* Map from MySQL commands to Drizzle commands. */
249
switch ((int)(*l_packet)[0])
250
{
251
case 0: /* SLEEP */
252
case 1: /* QUIT */
253
case 2: /* INIT_DB */
254
case 3: /* QUERY */
255
break;
256
257
case 8: /* SHUTDOWN */
258
(*l_packet)[0]= (unsigned char) COM_SHUTDOWN;
259
break;
260
261
case 14: /* PING */
262
(*l_packet)[0]= (unsigned char) COM_SHUTDOWN;
263
break;
264
265
266
default:
267
/* Just drop connection for MySQL commands we don't support. */
268
(*l_packet)[0]= (unsigned char) COM_QUIT;
269
*packet_length= 1;
270
break;
271
}
272
}
273
274
/* Do not rely on drizzleclient_net_read, extra safety against programming errors. */
275
(*l_packet)[*packet_length]= '\0'; /* safety */
276
277
#ifdef NEVER
278
/* See comment above. */
279
/* Restore read timeout value */
280
drizzleclient_net_set_read_timeout(&net,
281
session->variables.net_read_timeout);
282
#endif
283
284
return true;
285
}
286
287
/**
288
Return ok to the client.
289
290
The ok packet has the following structure:
291
292
- 0 : Marker (1 byte)
293
- affected_rows : Stored in 1-9 bytes
294
- id : Stored in 1-9 bytes
295
- server_status : Copy of session->server_status; Can be used by client
296
to check if we are inside an transaction.
297
New in 4.0 client
298
- warning_count : Stored in 2 bytes; New in 4.1 client
299
- message : Stored as packed length (1-9 bytes) + message.
300
Is not stored if no message.
301
302
@param session Thread handler
303
@param affected_rows Number of rows changed by statement
304
@param id Auto_increment id for first row (if used)
305
@param message Message to send to the client (Used by mysql_status)
306
*/
307
308
void ClientDrizzleProtocol::sendOK()
309
{
310
unsigned char buff[DRIZZLE_ERRMSG_SIZE+10],*pos;
311
const char *message= NULL;
312
uint32_t tmp;
313
314
if (!net.vio) // hack for re-parsing queries
315
{
316
return;
317
}
318
319
buff[0]=0; // No fields
320
if (session->main_da.status() == Diagnostics_area::DA_OK)
321
{
322
if (client_capabilities & CLIENT_FOUND_ROWS && session->main_da.found_rows())
323
pos=drizzleclient_net_store_length(buff+1,session->main_da.found_rows());
324
else
325
pos=drizzleclient_net_store_length(buff+1,session->main_da.affected_rows());
326
pos=drizzleclient_net_store_length(pos, session->main_da.last_insert_id());
327
int2store(pos, session->main_da.server_status());
328
pos+=2;
329
tmp= min(session->main_da.total_warn_count(), (uint32_t)65535);
330
message= session->main_da.message();
331
}
332
else
333
{
334
pos=drizzleclient_net_store_length(buff+1,0);
335
pos=drizzleclient_net_store_length(pos, 0);
336
int2store(pos, session->server_status);
337
pos+=2;
338
tmp= min(session->total_warn_count, (uint32_t)65535);
339
}
340
341
/* We can only return up to 65535 warnings in two bytes */
342
int2store(pos, tmp);
343
pos+= 2;
344
345
session->main_da.can_overwrite_status= true;
346
347
if (message && message[0])
348
{
349
size_t length= strlen(message);
350
pos=drizzleclient_net_store_length(pos,length);
351
memcpy(pos,(unsigned char*) message,length);
352
pos+=length;
353
}
354
drizzleclient_net_write(&net, buff, (size_t) (pos-buff));
355
drizzleclient_net_flush(&net);
356
357
session->main_da.can_overwrite_status= false;
358
}
359
360
/**
361
Send eof (= end of result set) to the client.
362
363
The eof packet has the following structure:
364
365
- 254 (DRIZZLE_PROTOCOL_NO_MORE_DATA) : Marker (1 byte)
366
- warning_count : Stored in 2 bytes; New in 4.1 client
367
- status_flag : Stored in 2 bytes;
368
For flags like SERVER_MORE_RESULTS_EXISTS.
369
370
Note that the warning count will not be sent if 'no_flush' is set as
371
we don't want to report the warning count until all data is sent to the
372
client.
373
*/
374
375
void ClientDrizzleProtocol::sendEOF()
376
{
377
/* Set to true if no active vio, to work well in case of --init-file */
378
if (net.vio != 0)
379
{
380
session->main_da.can_overwrite_status= true;
381
writeEOFPacket(session->main_da.server_status(),
382
session->main_da.total_warn_count());
383
drizzleclient_net_flush(&net);
384
session->main_da.can_overwrite_status= false;
385
}
386
packet.shrink(buffer_length);
387
}
388
389
390
void ClientDrizzleProtocol::sendError(uint32_t sql_errno, const char *err)
391
{
392
uint32_t length;
393
/*
394
buff[]: sql_errno:2 + ('#':1 + SQLSTATE_LENGTH:5) + DRIZZLE_ERRMSG_SIZE:512
395
*/
396
unsigned char buff[2+1+SQLSTATE_LENGTH+DRIZZLE_ERRMSG_SIZE], *pos;
397
398
assert(sql_errno);
399
assert(err && err[0]);
400
401
/*
402
It's one case when we can push an error even though there
403
is an OK or EOF already.
404
*/
405
session->main_da.can_overwrite_status= true;
406
407
/* Abort multi-result sets */
408
session->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
409
410
/**
411
Send a error string to client.
412
413
For SIGNAL/RESIGNAL and GET DIAGNOSTICS functionality it's
414
critical that every error that can be intercepted is issued in one
415
place only, my_message_sql.
416
*/
417
418
if (net.vio == 0)
419
{
420
return;
421
}
422
423
int2store(buff,sql_errno);
424
pos= buff+2;
425
426
/* The first # is to make the client backward compatible */
427
buff[2]= '#';
428
pos= (unsigned char*) strcpy((char*) buff+3, drizzle_errno_to_sqlstate(sql_errno));
429
pos+= strlen(drizzle_errno_to_sqlstate(sql_errno));
430
431
char *tmp= strncpy((char*)pos, err, DRIZZLE_ERRMSG_SIZE-1);
432
tmp+= strlen((char*)pos);
433
tmp[0]= '\0';
434
length= (uint32_t)(tmp-(char*)buff);
435
err= (char*) buff;
436
437
drizzleclient_net_write_command(&net,(unsigned char) 255, (unsigned char*) "", 0, (unsigned char*) err, length);
438
439
session->main_da.can_overwrite_status= false;
440
}
441
442
/**
443
Send name and type of result to client.
444
445
Sum fields has table name empty and field_name.
446
447
@param Session Thread data object
448
@param list List of items to send to client
449
@param flag Bit mask with the following functions:
450
- 1 send number of rows
451
- 2 send default values
452
- 4 don't write eof packet
453
454
@retval
455
0 ok
456
@retval
457
1 Error (Note that in this case the error is not sent to the
458
client)
459
*/
460
bool ClientDrizzleProtocol::sendFields(List<Item> *list)
461
{
462
List_iterator_fast<Item> it(*list);
463
Item *item;
464
unsigned char buff[80];
465
String tmp((char*) buff,sizeof(buff),&my_charset_bin);
466
467
unsigned char *row_pos= drizzleclient_net_store_length(buff, list->elements);
468
(void) drizzleclient_net_write(&net, buff, (size_t) (row_pos-buff));
469
470
while ((item=it++))
471
{
472
char *pos;
473
SendField field;
474
item->make_field(&field);
475
476
packet.length(0);
477
478
if (store(STRING_WITH_LEN("def")) ||
479
store(field.db_name) ||
480
store(field.table_name) ||
481
store(field.org_table_name) ||
482
store(field.col_name) ||
483
store(field.org_col_name) ||
484
packet.realloc(packet.length()+12))
485
goto err;
486
487
/* Store fixed length fields */
488
pos= (char*) packet.ptr()+packet.length();
489
*pos++= 12; // Length of packed fields
490
/* No conversion */
491
int2store(pos, field.charsetnr);
492
int4store(pos+2, field.length);
493
494
if (using_mysql41_protocol)
495
{
496
/* Switch to MySQL field numbering. */
497
switch (field.type)
498
{
499
case DRIZZLE_TYPE_LONG:
500
pos[6]= 3;
501
break;
502
503
case DRIZZLE_TYPE_DOUBLE:
504
pos[6]= 5;
505
break;
506
507
case DRIZZLE_TYPE_NULL:
508
pos[6]= 6;
509
break;
510
511
case DRIZZLE_TYPE_TIMESTAMP:
512
pos[6]= 7;
513
break;
514
515
case DRIZZLE_TYPE_LONGLONG:
516
pos[6]= 8;
517
break;
518
519
case DRIZZLE_TYPE_DATETIME:
520
pos[6]= 12;
521
break;
522
523
case DRIZZLE_TYPE_DATE:
524
pos[6]= 14;
525
break;
526
527
case DRIZZLE_TYPE_VARCHAR:
528
pos[6]= 15;
529
break;
530
531
case DRIZZLE_TYPE_DECIMAL:
532
pos[6]= (char)246;
533
break;
534
535
case DRIZZLE_TYPE_ENUM:
536
pos[6]= (char)247;
537
break;
538
539
case DRIZZLE_TYPE_BLOB:
540
pos[6]= (char)252;
541
break;
542
}
543
}
544
else
545
{
546
/* Add one to compensate for tinyint removal from enum. */
547
pos[6]= field.type + 1;
548
}
549
550
int2store(pos+7,field.flags);
551
pos[9]= (char) field.decimals;
552
pos[10]= 0; // For the future
553
pos[11]= 0; // For the future
554
pos+= 12;
555
556
packet.length((uint32_t) (pos - packet.ptr()));
557
if (flush())
558
break;
559
}
560
561
/*
562
Mark the end of meta-data result set, and store session->server_status,
563
to show that there is no cursor.
564
Send no warning information, as it will be sent at statement end.
565
*/
566
writeEOFPacket(session->server_status, session->total_warn_count);
567
return 0;
568
569
err:
570
my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES),
571
MYF(0));
572
return 1;
573
}
574
575
bool ClientDrizzleProtocol::store(Field *from)
576
{
577
if (from->is_null())
578
return store();
579
char buff[MAX_FIELD_WIDTH];
580
String str(buff,sizeof(buff), &my_charset_bin);
581
582
from->val_str(&str);
583
584
return netStoreData((const unsigned char *)str.ptr(), str.length());
585
}
586
587
bool ClientDrizzleProtocol::store(void)
588
{
589
char buff[1];
590
buff[0]= (char)251;
591
return packet.append(buff, sizeof(buff), PACKET_BUFFER_EXTRA_ALLOC);
592
}
593
594
bool ClientDrizzleProtocol::store(int32_t from)
595
{
596
char buff[12];
597
return netStoreData((unsigned char*) buff,
598
(size_t) (internal::int10_to_str(from, buff, -10) - buff));
599
}
600
601
bool ClientDrizzleProtocol::store(uint32_t from)
602
{
603
char buff[11];
604
return netStoreData((unsigned char*) buff,
605
(size_t) (internal::int10_to_str(from, buff, 10) - buff));
606
}
607
608
bool ClientDrizzleProtocol::store(int64_t from)
609
{
610
char buff[22];
611
return netStoreData((unsigned char*) buff,
612
(size_t) (internal::int64_t10_to_str(from, buff, -10) - buff));
613
}
614
615
bool ClientDrizzleProtocol::store(uint64_t from)
616
{
617
char buff[21];
618
return netStoreData((unsigned char*) buff,
619
(size_t) (internal::int64_t10_to_str(from, buff, 10) - buff));
620
}
621
622
bool ClientDrizzleProtocol::store(double from, uint32_t decimals, String *buffer)
623
{
624
buffer->set_real(from, decimals, session->charset());
625
return netStoreData((unsigned char*) buffer->ptr(), buffer->length());
626
}
627
628
bool ClientDrizzleProtocol::store(const char *from, size_t length)
629
{
630
return netStoreData((const unsigned char *)from, length);
631
}
632
633
bool ClientDrizzleProtocol::wasAborted(void)
634
{
635
return net.error && net.vio != 0;
636
}
637
638
bool ClientDrizzleProtocol::haveMoreData(void)
639
{
640
return drizzleclient_net_more_data(&net);
641
}
642
643
bool ClientDrizzleProtocol::haveError(void)
644
{
645
return net.error || net.vio == 0;
646
}
647
648
bool ClientDrizzleProtocol::checkConnection(void)
649
{
650
uint32_t pkt_len= 0;
651
char *end;
652
653
// TCP/IP connection
654
{
655
char ip[NI_MAXHOST];
656
uint16_t peer_port;
657
658
if (drizzleclient_net_peer_addr(&net, ip, &peer_port, NI_MAXHOST))
659
{
660
my_error(ER_BAD_HOST_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
661
return false;
662
}
663
664
session->getSecurityContext().setIp(ip);
665
}
666
drizzleclient_net_keepalive(&net, true);
667
668
uint32_t server_capabilites;
669
{
670
/* buff[] needs to big enough to hold the server_version variable */
671
char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH + 64];
672
673
server_capabilites= CLIENT_BASIC_FLAGS;
674
675
if (using_mysql41_protocol)
676
server_capabilites|= CLIENT_PROTOCOL_MYSQL41;
677
678
#ifdef HAVE_COMPRESS
679
server_capabilites|= CLIENT_COMPRESS;
680
#endif /* HAVE_COMPRESS */
681
682
end= buff + strlen(PANDORA_RELEASE_VERSION);
683
if ((end - buff) >= SERVER_VERSION_LENGTH)
684
end= buff + (SERVER_VERSION_LENGTH - 1);
685
memcpy(buff, PANDORA_RELEASE_VERSION, end - buff);
686
*end= 0;
687
end++;
688
689
int4store((unsigned char*) end, session->variables.pseudo_thread_id);
690
end+= 4;
691
692
/* We don't use scramble anymore. */
693
memset(end, 'X', SCRAMBLE_LENGTH_323);
694
end+= SCRAMBLE_LENGTH_323;
695
*end++= 0; /* an empty byte for some reason */
696
697
int2store(end, server_capabilites);
698
/* write server characteristics: up to 16 bytes allowed */
699
end[2]=(char) default_charset_info->number;
700
int2store(end+3, session->server_status);
701
memset(end+5, 0, 13);
702
end+= 18;
703
704
/* Write scramble tail. */
705
memset(end, 'X', SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323);
706
end+= (SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323);
707
*end++= 0; /* an empty byte for some reason */
708
709
/* At this point we write connection message and read reply */
710
if (drizzleclient_net_write_command(&net
711
, (unsigned char) PROTOCOL_VERSION
712
, (unsigned char*) ""
713
, 0
714
, (unsigned char*) buff
715
, (size_t) (end-buff))
716
|| (pkt_len= drizzleclient_net_read(&net)) == packet_error
717
|| pkt_len < MIN_HANDSHAKE_SIZE)
718
{
719
my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
720
return false;
721
}
722
}
723
if (packet.alloc(buffer_length))
724
return false; /* The error is set by alloc(). */
725
726
client_capabilities= uint2korr(net.read_pos);
727
728
729
client_capabilities|= ((uint32_t) uint2korr(net.read_pos + 2)) << 16;
730
session->max_client_packet_length= uint4korr(net.read_pos + 4);
731
end= (char*) net.read_pos + 32;
732
733
/*
734
Disable those bits which are not supported by the server.
735
This is a precautionary measure, if the client lies. See Bug#27944.
736
*/
737
client_capabilities&= server_capabilites;
738
739
if (end >= (char*) net.read_pos + pkt_len + 2)
740
{
741
my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
742
return false;
743
}
744
745
net.return_status= &session->server_status;
746
747
char *user= end;
748
char *passwd= strchr(user, '\0')+1;
749
uint32_t user_len= passwd - user - 1;
750
char *l_db= passwd;
751
752
/*
753
Old clients send null-terminated string as password; new clients send
754
the size (1 byte) + string (not null-terminated). Hence in case of empty
755
password both send '\0'.
756
757
This strlen() can't be easily deleted without changing client.
758
759
Cast *passwd to an unsigned char, so that it doesn't extend the sign for
760
*passwd > 127 and become 2**32-127+ after casting to uint.
761
*/
762
uint32_t passwd_len= client_capabilities & CLIENT_SECURE_CONNECTION ?
763
(unsigned char)(*passwd++) : strlen(passwd);
764
l_db= client_capabilities & CLIENT_CONNECT_WITH_DB ? l_db + passwd_len + 1 : 0;
765
766
/* strlen() can't be easily deleted without changing client */
767
uint32_t db_len= l_db ? strlen(l_db) : 0;
768
769
if (passwd + passwd_len + db_len > (char *) net.read_pos + pkt_len)
770
{
771
my_error(ER_HANDSHAKE_ERROR, MYF(0), session->getSecurityContext().getIp().c_str());
772
return false;
773
}
774
775
/* If username starts and ends in "'", chop them off */
776
if (user_len > 1 && user[0] == '\'' && user[user_len - 1] == '\'')
777
{
778
user[user_len-1]= 0;
779
user++;
780
user_len-= 2;
781
}
782
783
session->getSecurityContext().setUser(user);
784
785
return session->checkUser(passwd, passwd_len, l_db);
786
}
787
788
bool ClientDrizzleProtocol::netStoreData(const unsigned char *from, size_t length)
789
{
790
size_t packet_length= packet.length();
791
/*
792
The +9 comes from that strings of length longer than 16M require
793
9 bytes to be stored (see drizzleclient_net_store_length).
794
*/
795
if (packet_length+9+length > packet.alloced_length() &&
796
packet.realloc(packet_length+9+length))
797
return 1;
798
unsigned char *to= drizzleclient_net_store_length((unsigned char*) packet.ptr()+packet_length, length);
799
memcpy(to,from,length);
800
packet.length((size_t) (to+length-(unsigned char*) packet.ptr()));
801
return 0;
802
}
803
804
/**
805
Format EOF packet according to the current client and
806
write it to the network output buffer.
807
*/
808
809
void ClientDrizzleProtocol::writeEOFPacket(uint32_t server_status,
810
uint32_t total_warn_count)
811
{
812
unsigned char buff[5];
813
/*
814
Don't send warn count during SP execution, as the warn_list
815
is cleared between substatements, and mysqltest gets confused
816
*/
817
uint32_t tmp= min(total_warn_count, (uint32_t)65535);
818
buff[0]= DRIZZLE_PROTOCOL_NO_MORE_DATA;
819
int2store(buff+1, tmp);
820
/*
821
The following test should never be true, but it's better to do it
822
because if 'is_fatal_error' is set the server is not going to execute
823
other queries (see the if test in dispatch_command / COM_QUERY)
824
*/
825
if (session->is_fatal_error)
826
server_status&= ~SERVER_MORE_RESULTS_EXISTS;
827
int2store(buff + 3, server_status);
828
drizzleclient_net_write(&net, buff, 5);
829
}
830
831
static int init(module::Context &context)
832
{
833
drizzle_status_table_function_ptr= new DrizzleProtocolStatus;
834
835
context.add(drizzle_status_table_function_ptr);
836
70
static int init(drizzled::module::Context &context)
71
{
837
72
const module::option_map &vm= context.getOptions();
838
73
if (vm.count("port"))
839
74
{
875
110
{
876
111
if (retry_count < 1 || retry_count > 100)
877
112
{
878
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for retry_count\n"));
113
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for retry_count"));
879
114
exit(-1);
880
115
}
881
116
}
898
133
{
899
134
bind_address= NULL;
900
135
}
901
902
context.add(new ListenDrizzleProtocol("drizzle_protocol", false));
136
137
context.add(new StatusTable);
138
context.add(new ListenDrizzleProtocol("drizzle_protocol", true));
139
903
140
return 0;
904
141
}
905
142
906
143
static DRIZZLE_SYSVAR_UINT(port, port, PLUGIN_VAR_RQCMDARG,
907
N_("Port number to use for connection or 0 for "
908
"default to, in order of "
909
"preference, drizzle.cnf, $DRIZZLE_TCP_PORT, "
910
"built-in default (4427)."),
911
NULL, NULL, 0, 0, 65535, 0);
144
N_("Port number to use for connection or 0 for default to with Drizzle/MySQL protocol."),
145
NULL, NULL, DRIZZLE_TCP_PORT, 0, 65535, 0);
912
146
static DRIZZLE_SYSVAR_UINT(connect_timeout, connect_timeout,
913
147
PLUGIN_VAR_RQCMDARG, N_("Connect Timeout."),
914
148
NULL, NULL, 10, 1, 300, 0);
927
161
static void init_options(drizzled::module::option_context &context)
928
162
{
929
163
context("port",
930
po::value<uint32_t>(&port)->default_value(0),
931
N_("Port number to use for connection or 0 for "
932
"default to, in order of "
933
"preference, drizzle.cnf, $DRIZZLE_TCP_PORT, "
934
"built-in default (4427)."));
164
po::value<uint32_t>(&port)->default_value(DRIZZLE_TCP_PORT),
165
N_("Port number to use for connection or 0 for default to with Drizzle/MySQL protocol."));
935
166
context("connect-timeout",
936
167
po::value<uint32_t>(&connect_timeout)->default_value(10),
937
168
N_("Connect Timeout."));
963
194
NULL
964
195
};
965
196
966
static int drizzle_protocol_connection_count_func(drizzle_show_var *var, char *buff)
967
{
968
var->type= SHOW_LONGLONG;
969
var->value= buff;
970
*((uint64_t *)buff)= ClientDrizzleProtocol::connectionCount;
971
return 0;
972
}
973
974
static int drizzle_protocol_connected_count_func(drizzle_show_var *var, char *buff)
975
{
976
var->type= SHOW_LONGLONG;
977
var->value= buff;
978
*((uint64_t *)buff)= ClientDrizzleProtocol::connected;
979
return 0;
980
}
981
982
static int drizzle_protocol_failed_count_func(drizzle_show_var *var, char *buff)
983
{
984
var->type= SHOW_LONGLONG;
985
var->value= buff;
986
*((uint64_t *)buff)= ClientDrizzleProtocol::failedConnections;
987
return 0;
988
}
989
990
static st_show_var_func_container drizzle_protocol_connection_count=
991
{ &drizzle_protocol_connection_count_func };
992
993
static st_show_var_func_container drizzle_protocol_connected_count=
994
{ &drizzle_protocol_connected_count_func };
995
996
static st_show_var_func_container drizzle_protocol_failed_count=
997
{ &drizzle_protocol_failed_count_func };
998
999
static drizzle_show_var drizzle_protocol_status_variables[]= {
1000
{"Connections",
1001
(char*) &drizzle_protocol_connection_count, SHOW_FUNC},
1002
{"Connected",
1003
(char*) &drizzle_protocol_connected_count, SHOW_FUNC},
1004
{"Failed_connections",
1005
(char*) &drizzle_protocol_failed_count, SHOW_FUNC},
1006
{NULL, NULL, SHOW_LONGLONG}
1007
};
1008
1009
DrizzleProtocolStatus::Generator::Generator(drizzled::Field **fields) :
1010
plugin::TableFunction::Generator(fields)
1011
{
1012
status_var_ptr= drizzle_protocol_status_variables;
1013
}
1014
1015
bool DrizzleProtocolStatus::Generator::populate()
1016
{
1017
MY_ALIGNED_BYTE_ARRAY(buff_data, SHOW_VAR_FUNC_BUFF_SIZE, int64_t);
1018
char * const buff= (char *) &buff_data;
1019
drizzle_show_var tmp;
1020
1021
if (status_var_ptr->name)
1022
{
1023
std::ostringstream oss;
1024
string return_value;
1025
const char *value;
1026
int type;
1027
1028
push(status_var_ptr->name);
1029
1030
if (status_var_ptr->type == SHOW_FUNC)
1031
{
1032
((mysql_show_var_func)((st_show_var_func_container *)status_var_ptr->value)->func)(&tmp, buff);
1033
value= buff;
1034
type= tmp.type;
1035
}
1036
else
1037
{
1038
value= status_var_ptr->value;
1039
type= status_var_ptr->type;
1040
}
1041
1042
switch(type)
1043
{
1044
case SHOW_LONGLONG:
1045
oss << *(uint64_t*) value;
1046
return_value= oss.str();
1047
break;
1048
default:
1049
assert(0);
1050
}
1051
if (return_value.length())
1052
push(return_value);
1053
else
1054
push(" ");
1055
1056
status_var_ptr++;
1057
1058
return true;
1059
}
1060
return false;
1061
}
1062
1063
197
} /* namespace drizzle_protocol */
1064
198
1065
199
DRIZZLE_PLUGIN(drizzle_protocol::init, drizzle_protocol::sys_variables, drizzle_protocol::init_options);
Loggerhead is a web-based interface for Breezy
Version: 2.0.1