← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/oldlibdrizzle/oldlibdrizzle.cc

Merged Nathan from lp:~nlws/drizzle/fix-string-c-ptr-overrun

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/oldlibdrizzle/oldlibdrizzle.cc
1
 
/* Copyright (C) 2000-2003 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 Sun Microsystems
 
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
 
18
 */
15
19
 
16
20
/**
17
21
  @file
19
23
  Low level functions for storing data to be send to the MySQL client.
20
24
  The actual communction is handled by the net_xxx functions in net_serv.cc
21
25
*/
 
26
 
22
27
#include <drizzled/server_includes.h>
23
28
#include <drizzled/error.h>
24
29
#include <drizzled/sql_state.h>
25
 
#include <libdrizzle/pack.h>
26
30
#include <drizzled/protocol.h>
27
31
#include <drizzled/session.h>
 
32
#include <drizzled/data_home.h>
 
33
#include "pack.h"
 
34
#include "errmsg.h"
 
35
#include "oldlibdrizzle.h"
 
36
 
 
37
/*
 
38
  Function called by drizzleclient_net_init() to set some check variables
 
39
*/
28
40
 
29
41
static const unsigned int PACKET_BUFFER_EXTRA_ALLOC= 1024;
30
 
/* Declared non-static only because of the embedded library. */
31
 
static void net_send_error_packet(Session *session, uint32_t sql_errno, const char *err);
 
42
 
32
43
static void write_eof_packet(Session *session, NET *net,
33
44
                             uint32_t server_status, uint32_t total_warn_count);
34
45
 
35
 
bool Protocol::net_store_data(const unsigned char *from, size_t length)
 
46
bool ProtocolOldLibdrizzle::isConnected()
 
47
{
 
48
  return net.vio != 0;
 
49
}
 
50
 
 
51
void ProtocolOldLibdrizzle::setReadTimeout(uint32_t timeout)
 
52
{
 
53
  drizzleclient_net_set_read_timeout(&net, timeout);
 
54
}
 
55
 
 
56
void ProtocolOldLibdrizzle::setWriteTimeout(uint32_t timeout)
 
57
{
 
58
  drizzleclient_net_set_write_timeout(&net, timeout);
 
59
}
 
60
 
 
61
void ProtocolOldLibdrizzle::setRetryCount(uint32_t count)
 
62
{
 
63
  net.retry_count=count;
 
64
}
 
65
 
 
66
void ProtocolOldLibdrizzle::setError(char error)
 
67
{
 
68
  net.error= error;
 
69
}
 
70
 
 
71
bool ProtocolOldLibdrizzle::haveError(void)
 
72
{
 
73
  return net.error || net.vio == 0;
 
74
}
 
75
 
 
76
bool ProtocolOldLibdrizzle::wasAborted(void)
 
77
{
 
78
  return net.error && net.vio != 0;
 
79
}
 
80
 
 
81
bool ProtocolOldLibdrizzle::haveMoreData(void)
 
82
{
 
83
  return drizzleclient_net_more_data(&net);
 
84
}
 
85
 
 
86
void ProtocolOldLibdrizzle::enableCompression(void)
 
87
{
 
88
  net.compress= true;
 
89
}
 
90
 
 
91
bool ProtocolOldLibdrizzle::isReading(void)
 
92
{
 
93
  return net.reading_or_writing == 1;
 
94
}
 
95
 
 
96
bool ProtocolOldLibdrizzle::isWriting(void)
 
97
{
 
98
  return net.reading_or_writing == 2;
 
99
}
 
100
 
 
101
bool ProtocolOldLibdrizzle::netStoreData(const unsigned char *from, size_t length)
36
102
{
37
103
  size_t packet_length= packet->length();
38
 
  /* 
 
104
  /*
39
105
     The +9 comes from that strings of length longer than 16M require
40
 
     9 bytes to be stored (see net_store_length).
 
106
     9 bytes to be stored (see drizzleclient_net_store_length).
41
107
  */
42
108
  if (packet_length+9+length > packet->alloced_length() &&
43
109
      packet->realloc(packet_length+9+length))
44
110
    return 1;
45
 
  unsigned char *to= net_store_length((unsigned char*) packet->ptr()+packet_length, length);
 
111
  unsigned char *to= drizzleclient_net_store_length((unsigned char*) packet->ptr()+packet_length, length);
46
112
  memcpy(to,from,length);
47
113
  packet->length((size_t) (to+length-(unsigned char*) packet->ptr()));
48
114
  return 0;
49
115
}
50
116
 
51
117
 
52
 
 
53
 
 
54
118
/*
55
 
  net_store_data() - extended version with character set conversion.
56
 
  
 
119
  netStoreData() - extended version with character set conversion.
 
120
 
57
121
  It is optimized for short strings whose length after
58
122
  conversion is garanteed to be less than 251, which accupies
59
123
  exactly one byte to store length. It allows not to use
63
127
  because column, table, database names fit into this limit.
64
128
*/
65
129
 
66
 
bool Protocol::net_store_data(const unsigned char *from, size_t length,
 
130
bool ProtocolOldLibdrizzle::netStoreData(const unsigned char *from, size_t length,
67
131
                              const CHARSET_INFO * const from_cs,
68
 
                                                          const CHARSET_INFO * const to_cs)
 
132
                              const CHARSET_INFO * const to_cs)
69
133
{
70
134
  uint32_t dummy_errors;
71
135
  /* Calculate maxumum possible result length */
79
143
      For example, when converting from utf8 (mbmaxlen=3) to latin1,
80
144
      conv_length=300 means that the result length can vary between 100 to 300.
81
145
      length=100 needs one byte, length=300 needs to bytes.
82
 
      
 
146
 
83
147
      Thus conversion directly to "packet" is not worthy.
84
148
      Let's use "convert" as a temporary buffer.
85
149
    */
86
150
    return (convert->copy((const char*) from, length, from_cs,
87
151
                          to_cs, &dummy_errors) ||
88
 
            net_store_data((const unsigned char*) convert->ptr(), convert->length()));
 
152
            netStoreData((const unsigned char*) convert->ptr(), convert->length()));
89
153
  }
90
154
 
91
155
  size_t packet_length= packet->length();
100
164
  to+= copy_and_convert(to, conv_length, to_cs,
101
165
                        (const char*) from, length, from_cs, &dummy_errors);
102
166
 
103
 
  net_store_length((unsigned char*) length_pos, to - length_pos - 1);
104
 
  packet->length((uint) (to - packet->ptr()));
 
167
  drizzleclient_net_store_length((unsigned char*) length_pos, to - length_pos - 1);
 
168
  packet->length((uint32_t) (to - packet->ptr()));
105
169
  return 0;
106
170
}
107
171
 
108
172
 
109
173
/**
110
 
  Send a error string to client.
111
 
 
112
 
  Design note:
113
 
  net_printf_error and net_send_error are low-level functions
114
 
  that shall be used only when a new connection is being
115
 
  established or at server startup.
116
 
 
117
 
  For SIGNAL/RESIGNAL and GET DIAGNOSTICS functionality it's
118
 
  critical that every error that can be intercepted is issued in one
119
 
  place only, my_message_sql.
120
 
*/
121
 
void net_send_error(Session *session, uint32_t sql_errno, const char *err)
122
 
{
123
 
  assert(sql_errno);
124
 
  assert(err && err[0]);
125
 
 
126
 
  /*
127
 
    It's one case when we can push an error even though there
128
 
    is an OK or EOF already.
129
 
  */
130
 
  session->main_da.can_overwrite_status= true;
131
 
 
132
 
  /* Abort multi-result sets */
133
 
  session->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
134
 
 
135
 
  net_send_error_packet(session, sql_errno, err);
136
 
 
137
 
  session->main_da.can_overwrite_status= false;
138
 
}
139
 
 
140
 
/**
141
174
  Return ok to the client.
142
175
 
143
176
  The ok packet has the following structure:
144
177
 
145
178
  - 0               : Marker (1 byte)
146
 
  - affected_rows       : Stored in 1-9 bytes
147
 
  - id          : Stored in 1-9 bytes
148
 
  - server_status       : Copy of session->server_status;  Can be used by client
 
179
  - affected_rows    : Stored in 1-9 bytes
 
180
  - id        : Stored in 1-9 bytes
 
181
  - server_status    : Copy of session->server_status;  Can be used by client
149
182
  to check if we are inside an transaction.
150
183
  New in 4.0 protocol
151
 
  - warning_count       : Stored in 2 bytes; New in 4.1 protocol
152
 
  - message             : Stored as packed length (1-9 bytes) + message.
 
184
  - warning_count    : Stored in 2 bytes; New in 4.1 protocol
 
185
  - message        : Stored as packed length (1-9 bytes) + message.
153
186
  Is not stored if no message.
154
187
 
155
 
  @param session                   Thread handler
156
 
  @param affected_rows     Number of rows changed by statement
157
 
  @param id                Auto_increment id for first row (if used)
158
 
  @param message           Message to send to the client (Used by mysql_status)
 
188
  @param session           Thread handler
 
189
  @param affected_rows       Number of rows changed by statement
 
190
  @param id           Auto_increment id for first row (if used)
 
191
  @param message       Message to send to the client (Used by mysql_status)
159
192
*/
160
193
 
161
 
static void
162
 
net_send_ok(Session *session,
163
 
            uint32_t server_status, uint32_t total_warn_count,
164
 
            ha_rows affected_rows, uint64_t id, const char *message)
 
194
void ProtocolOldLibdrizzle::sendOK()
165
195
{
166
 
  NET *net= &session->net;
167
196
  unsigned char buff[DRIZZLE_ERRMSG_SIZE+10],*pos;
 
197
  const char *message= NULL;
 
198
  uint32_t tmp;
168
199
 
169
 
  if (! net->vio)       // hack for re-parsing queries
 
200
  if (!net.vio)    // hack for re-parsing queries
170
201
  {
171
202
    return;
172
203
  }
173
204
 
174
 
  buff[0]=0;                                    // No fields
175
 
  pos=net_store_length(buff+1,affected_rows);
176
 
  pos=net_store_length(pos, id);
177
 
 
178
 
  int2store(pos, server_status);
179
 
  pos+=2;
 
205
  buff[0]=0;                    // No fields
 
206
  if (session->main_da.status() == Diagnostics_area::DA_OK)
 
207
  {
 
208
    pos=drizzleclient_net_store_length(buff+1,session->main_da.affected_rows());
 
209
    pos=drizzleclient_net_store_length(pos, session->main_da.last_insert_id());
 
210
    int2store(pos, session->main_da.server_status());
 
211
    pos+=2;
 
212
    tmp= cmin(session->main_da.total_warn_count(), (uint32_t)65535);
 
213
    message= session->main_da.message();
 
214
  }
 
215
  else
 
216
  {
 
217
    pos=drizzleclient_net_store_length(buff+1,0);
 
218
    pos=drizzleclient_net_store_length(pos, 0);
 
219
    int2store(pos, session->server_status);
 
220
    pos+=2;
 
221
    tmp= cmin(session->total_warn_count, (uint32_t)65535);
 
222
  }
180
223
 
181
224
  /* We can only return up to 65535 warnings in two bytes */
182
 
  uint32_t tmp= cmin(total_warn_count, (uint)65535);
183
225
  int2store(pos, tmp);
184
226
  pos+= 2;
185
227
 
186
228
  session->main_da.can_overwrite_status= true;
187
229
 
188
230
  if (message && message[0])
189
 
    pos= net_store_data(pos, (unsigned char*) message, strlen(message));
190
 
  my_net_write(net, buff, (size_t) (pos-buff));
191
 
  net_flush(net);
 
231
  {
 
232
    size_t length= strlen(message);
 
233
    pos=drizzleclient_net_store_length(pos,length);
 
234
    memcpy(pos,(unsigned char*) message,length);
 
235
    pos+=length;
 
236
  }
 
237
  drizzleclient_net_write(&net, buff, (size_t) (pos-buff));
 
238
  drizzleclient_net_flush(&net);
192
239
 
193
240
  session->main_da.can_overwrite_status= false;
194
241
}
198
245
 
199
246
  The eof packet has the following structure:
200
247
 
201
 
  - 254 (DRIZZLE_PROTOCOL_NO_MORE_DATA) : Marker (1 byte)
202
 
  - warning_count       : Stored in 2 bytes; New in 4.1 protocol
203
 
  - status_flag : Stored in 2 bytes;
 
248
  - 254    (DRIZZLE_PROTOCOL_NO_MORE_DATA)    : Marker (1 byte)
 
249
  - warning_count    : Stored in 2 bytes; New in 4.1 protocol
 
250
  - status_flag    : Stored in 2 bytes;
204
251
  For flags like SERVER_MORE_RESULTS_EXISTS.
205
252
 
206
253
  Note that the warning count will not be sent if 'no_flush' is set as
207
254
  we don't want to report the warning count until all data is sent to the
208
255
  client.
209
 
 
210
 
  @param session                Thread handler
211
 
  @param no_flush       Set to 1 if there will be more data to the client,
212
 
                    like in send_fields().
213
 
*/    
214
 
 
215
 
static void
216
 
net_send_eof(Session *session, uint32_t server_status, uint32_t total_warn_count)
 
256
*/
 
257
 
 
258
void ProtocolOldLibdrizzle::sendEOF()
217
259
{
218
 
  NET *net= &session->net;
219
260
  /* Set to true if no active vio, to work well in case of --init-file */
220
 
  if (net->vio != 0)
 
261
  if (net.vio != 0)
221
262
  {
222
263
    session->main_da.can_overwrite_status= true;
223
 
    write_eof_packet(session, net, server_status, total_warn_count);
224
 
    net_flush(net);
 
264
    write_eof_packet(session, &net, session->main_da.server_status(),
 
265
                     session->main_da.total_warn_count());
 
266
    drizzleclient_net_flush(&net);
225
267
    session->main_da.can_overwrite_status= false;
226
268
  }
227
269
}
241
283
    Don't send warn count during SP execution, as the warn_list
242
284
    is cleared between substatements, and mysqltest gets confused
243
285
  */
244
 
  uint32_t tmp= cmin(total_warn_count, (uint)65535);
 
286
  uint32_t tmp= cmin(total_warn_count, (uint32_t)65535);
245
287
  buff[0]= DRIZZLE_PROTOCOL_NO_MORE_DATA;
246
288
  int2store(buff+1, tmp);
247
289
  /*
252
294
  if (session->is_fatal_error)
253
295
    server_status&= ~SERVER_MORE_RESULTS_EXISTS;
254
296
  int2store(buff + 3, server_status);
255
 
  my_net_write(net, buff, 5);
 
297
  drizzleclient_net_write(net, buff, 5);
256
298
}
257
299
 
258
 
void net_send_error_packet(Session *session, uint32_t sql_errno, const char *err)
 
300
void ProtocolOldLibdrizzle::sendError(uint32_t sql_errno, const char *err)
259
301
{
260
 
  NET *net= &session->net;
261
302
  uint32_t length;
262
303
  /*
263
304
    buff[]: sql_errno:2 + ('#':1 + SQLSTATE_LENGTH:5) + DRIZZLE_ERRMSG_SIZE:512
264
305
  */
265
306
  unsigned char buff[2+1+SQLSTATE_LENGTH+DRIZZLE_ERRMSG_SIZE], *pos;
266
307
 
267
 
  if (net->vio == 0)
 
308
  assert(sql_errno);
 
309
  assert(err && err[0]);
 
310
 
 
311
  /*
 
312
    It's one case when we can push an error even though there
 
313
    is an OK or EOF already.
 
314
  */
 
315
  session->main_da.can_overwrite_status= true;
 
316
 
 
317
  /* Abort multi-result sets */
 
318
  session->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
 
319
 
 
320
  /**
 
321
    Send a error string to client.
 
322
 
 
323
    For SIGNAL/RESIGNAL and GET DIAGNOSTICS functionality it's
 
324
    critical that every error that can be intercepted is issued in one
 
325
    place only, my_message_sql.
 
326
  */
 
327
 
 
328
  if (net.vio == 0)
268
329
  {
269
330
    return;
270
331
  }
274
335
 
275
336
  /* The first # is to make the protocol backward compatible */
276
337
  buff[2]= '#';
277
 
  pos= (unsigned char*) my_stpcpy((char*) buff+3, drizzle_errno_to_sqlstate(sql_errno));
 
338
  pos= (unsigned char*) strcpy((char*) buff+3, drizzle_errno_to_sqlstate(sql_errno));
 
339
  pos+= strlen(drizzle_errno_to_sqlstate(sql_errno));
278
340
 
279
 
  length= (uint) (strmake((char*) pos, err, DRIZZLE_ERRMSG_SIZE-1) -
280
 
                  (char*) buff);
 
341
  char *tmp= strncpy((char*)pos, err, DRIZZLE_ERRMSG_SIZE-1);
 
342
  tmp+= strlen((char*)pos);
 
343
  tmp[0]= '\0';
 
344
  length= (uint32_t)(tmp-(char*)buff);
281
345
  err= (char*) buff;
282
346
 
283
 
  net_write_command(net,(unsigned char) 255, (unsigned char*) "", 0, (unsigned char*) err, length);
284
 
  return;
285
 
}
286
 
 
287
 
 
288
 
/**
289
 
  Faster net_store_length when we know that length is less than 65536.
290
 
  We keep a separate version for that range because it's widely used in
291
 
  libmysql.
292
 
 
293
 
  uint32_t is used as agrument type because of MySQL type conventions:
294
 
  - uint32_t for 0..65536
295
 
  - ulong for 0..4294967296
296
 
  - uint64_t for bigger numbers.
297
 
*/
298
 
 
299
 
static unsigned char *net_store_length_fast(unsigned char *packet, uint32_t length)
300
 
{
301
 
  if (length < 251)
302
 
  {
303
 
    *packet=(unsigned char) length;
304
 
    return packet+1;
305
 
  }
306
 
  *packet++=252;
307
 
  int2store(packet,(uint32_t) length);
308
 
 
309
 
  return packet+2;
310
 
}
311
 
 
312
 
/**
313
 
  Send the status of the current statement execution over network.
314
 
 
315
 
  @param  session   in fact, carries two parameters, NET for the transport and
316
 
                Diagnostics_area as the source of status information.
317
 
 
318
 
  In MySQL, there are two types of SQL statements: those that return
319
 
  a result set and those that return status information only.
320
 
 
321
 
  If a statement returns a result set, it consists of 3 parts:
322
 
  - result set meta-data
323
 
  - variable number of result set rows (can be 0)
324
 
  - followed and terminated by EOF or ERROR packet
325
 
 
326
 
  Once the  client has seen the meta-data information, it always
327
 
  expects an EOF or ERROR to terminate the result set. If ERROR is
328
 
  received, the result set rows are normally discarded (this is up
329
 
  to the client implementation, libmysql at least does discard them).
330
 
  EOF, on the contrary, means "successfully evaluated the entire
331
 
  result set". Since we don't know how many rows belong to a result
332
 
  set until it's evaluated, EOF/ERROR is the indicator of the end
333
 
  of the row stream. Note, that we can not buffer result set rows
334
 
  on the server -- there may be an arbitrary number of rows. But
335
 
  we do buffer the last packet (EOF/ERROR) in the Diagnostics_area and
336
 
  delay sending it till the very end of execution (here), to be able to
337
 
  change EOF to an ERROR if commit failed or some other error occurred
338
 
  during the last cleanup steps taken after execution.
339
 
 
340
 
  A statement that does not return a result set doesn't send result
341
 
  set meta-data either. Instead it returns one of:
342
 
  - OK packet
343
 
  - ERROR packet.
344
 
  Similarly to the EOF/ERROR of the previous statement type, OK/ERROR
345
 
  packet is "buffered" in the diagnostics area and sent to the client
346
 
  in the end of statement.
347
 
 
348
 
  @pre  The diagnostics area is assigned or disabled. It can not be empty
349
 
        -- we assume that every SQL statement or COM_* command
350
 
        generates OK, ERROR, or EOF status.
351
 
 
352
 
  @post The status information is encoded to protocol format and sent to the
353
 
        client.
354
 
 
355
 
  @return We conventionally return void, since the only type of error
356
 
          that can happen here is a NET (transport) error, and that one
357
 
          will become visible when we attempt to read from the NET the
358
 
          next command.
359
 
          Diagnostics_area::is_sent is set for debugging purposes only.
360
 
*/
361
 
 
362
 
void net_end_statement(Session *session)
363
 
{
364
 
  assert(! session->main_da.is_sent);
365
 
 
366
 
  /* Can not be true, but do not take chances in production. */
367
 
  if (session->main_da.is_sent)
368
 
    return;
369
 
 
370
 
  switch (session->main_da.status()) {
371
 
  case Diagnostics_area::DA_ERROR:
372
 
    /* The query failed, send error to log and abort bootstrap. */
373
 
    net_send_error(session,
374
 
                   session->main_da.sql_errno(),
375
 
                   session->main_da.message());
376
 
    break;
377
 
  case Diagnostics_area::DA_EOF:
378
 
    net_send_eof(session,
379
 
                 session->main_da.server_status(),
380
 
                 session->main_da.total_warn_count());
381
 
    break;
382
 
  case Diagnostics_area::DA_OK:
383
 
    net_send_ok(session,
384
 
                session->main_da.server_status(),
385
 
                session->main_da.total_warn_count(),
386
 
                session->main_da.affected_rows(),
387
 
                session->main_da.last_insert_id(),
388
 
                session->main_da.message());
389
 
    break;
390
 
  case Diagnostics_area::DA_DISABLED:
391
 
    break;
392
 
  case Diagnostics_area::DA_EMPTY:
393
 
  default:
394
 
    assert(0);
395
 
    net_send_ok(session, session->server_status, session->total_warn_count,
396
 
                0, 0, NULL);
397
 
    break;
398
 
  }
399
 
  session->main_da.is_sent= true;
400
 
}
401
 
 
402
 
 
403
 
/****************************************************************************
404
 
  Functions used by the protocol functions (like net_send_ok) to store
405
 
  strings and numbers in the header result packet.
406
 
****************************************************************************/
407
 
 
408
 
/* The following will only be used for short strings < 65K */
409
 
 
410
 
unsigned char *net_store_data(unsigned char *to, const unsigned char *from, size_t length)
411
 
{
412
 
  to=net_store_length_fast(to,length);
413
 
  memcpy(to,from,length);
414
 
  return to+length;
415
 
}
416
 
 
417
 
unsigned char *net_store_data(unsigned char *to,int32_t from)
418
 
{
419
 
  char buff[20];
420
 
  uint32_t length=(uint) (int10_to_str(from,buff,10)-buff);
421
 
  to=net_store_length_fast(to,length);
422
 
  memcpy(to,buff,length);
423
 
  return to+length;
424
 
}
425
 
 
426
 
unsigned char *net_store_data(unsigned char *to,int64_t from)
427
 
{
428
 
  char buff[22];
429
 
  uint32_t length=(uint) (int64_t10_to_str(from,buff,10)-buff);
430
 
  to=net_store_length_fast(to,length);
431
 
  memcpy(to,buff,length);
432
 
  return to+length;
433
 
}
434
 
 
435
 
 
436
 
/*****************************************************************************
437
 
  Default Protocol functions
438
 
*****************************************************************************/
439
 
 
440
 
void Protocol::init(Session *session_arg)
441
 
{
442
 
  session=session_arg;
 
347
  drizzleclient_net_write_command(&net,(unsigned char) 255, (unsigned char*) "", 0, (unsigned char*) err, length);
 
348
 
 
349
  session->main_da.can_overwrite_status= false;
 
350
}
 
351
 
 
352
 
 
353
ProtocolOldLibdrizzle::ProtocolOldLibdrizzle()
 
354
{
 
355
  scramble[0]= 0;
 
356
  net.vio= 0;
 
357
}
 
358
 
 
359
void ProtocolOldLibdrizzle::setSession(Session *session_arg)
 
360
{
 
361
  session= session_arg;
443
362
  packet= &session->packet;
444
363
  convert= &session->convert_buffer;
445
364
}
446
365
 
447
 
/**
448
 
  Finish the result set with EOF packet, as is expected by the client,
449
 
  if there is an error evaluating the next row and a continue handler
450
 
  for the error.
451
 
*/
452
 
 
453
 
void Protocol::end_partial_result_set(Session *session)
454
 
{
455
 
  net_send_eof(session, session->server_status, 0 /* no warnings, we're inside SP */);
456
 
}
457
 
 
458
 
 
459
 
bool Protocol::flush()
460
 
{
461
 
  return net_flush(&session->net);
462
 
}
463
 
 
464
366
 
465
367
/**
466
368
  Send name and type of result to client.
467
369
 
468
370
  Sum fields has table name empty and field_name.
469
371
 
470
 
  @param Session                Thread data object
471
 
  @param list           List of items to send to client
472
 
  @param flag           Bit mask with the following functions:
 
372
  @param Session        Thread data object
 
373
  @param list            List of items to send to client
 
374
  @param flag            Bit mask with the following functions:
473
375
                        - 1 send number of rows
474
376
                        - 2 send default values
475
377
                        - 4 don't write eof packet
476
378
 
477
379
  @retval
478
 
    0   ok
 
380
    0    ok
479
381
  @retval
480
 
    1   Error  (Note that in this case the error is not sent to the
 
382
    1    Error  (Note that in this case the error is not sent to the
481
383
    client)
482
384
*/
483
 
bool Protocol::send_fields(List<Item> *list, uint32_t flags)
 
385
bool ProtocolOldLibdrizzle::sendFields(List<Item> *list, uint32_t flags)
484
386
{
485
387
  List_iterator_fast<Item> it(*list);
486
388
  Item *item;
487
389
  unsigned char buff[80];
488
390
  String tmp((char*) buff,sizeof(buff),&my_charset_bin);
489
 
  Protocol_text prot(session);
490
 
  String *local_packet= prot.storage_packet();
491
 
  const CHARSET_INFO * const session_charset= session->variables.character_set_results;
492
391
 
493
392
  if (flags & SEND_NUM_ROWS)
494
 
  {                             // Packet with number of elements
495
 
    unsigned char *pos= net_store_length(buff, list->elements);
496
 
    (void) my_net_write(&session->net, buff, (size_t) (pos-buff));
 
393
  {                // Packet with number of elements
 
394
    unsigned char *pos= drizzleclient_net_store_length(buff, list->elements);
 
395
    (void) drizzleclient_net_write(&net, buff, (size_t) (pos-buff));
497
396
  }
498
397
 
499
398
  while ((item=it++))
503
402
    Send_field field;
504
403
    item->make_field(&field);
505
404
 
506
 
    prot.prepare_for_resend();
507
 
 
508
 
 
509
 
    if (prot.store(STRING_WITH_LEN("def"), cs, session_charset) ||
510
 
        prot.store(field.db_name, (uint) strlen(field.db_name),
511
 
                   cs, session_charset) ||
512
 
        prot.store(field.table_name, (uint) strlen(field.table_name),
513
 
                   cs, session_charset) ||
514
 
        prot.store(field.org_table_name, (uint) strlen(field.org_table_name),
515
 
                   cs, session_charset) ||
516
 
        prot.store(field.col_name, (uint) strlen(field.col_name),
517
 
                   cs, session_charset) ||
518
 
        prot.store(field.org_col_name, (uint) strlen(field.org_col_name),
519
 
                   cs, session_charset) ||
520
 
        local_packet->realloc(local_packet->length()+12))
 
405
    prepareForResend();
 
406
 
 
407
    if (store(STRING_WITH_LEN("def"), cs) ||
 
408
        store(field.db_name, cs) ||
 
409
        store(field.table_name, cs) ||
 
410
        store(field.org_table_name, cs) ||
 
411
        store(field.col_name, cs) ||
 
412
        store(field.org_col_name, cs) ||
 
413
        packet->realloc(packet->length()+12))
521
414
      goto err;
522
415
 
523
416
    /* Store fixed length fields */
524
 
    pos= (char*) local_packet->ptr()+local_packet->length();
525
 
    *pos++= 12;                         // Length of packed fields
526
 
    if (item->collation.collation == &my_charset_bin || session_charset == NULL)
 
417
    pos= (char*) packet->ptr()+packet->length();
 
418
    *pos++= 12;                // Length of packed fields
 
419
    if (item->collation.collation == &my_charset_bin)
527
420
    {
528
421
      /* No conversion */
529
422
      int2store(pos, field.charsetnr);
533
426
    {
534
427
      /* With conversion */
535
428
      uint32_t max_char_len;
536
 
      int2store(pos, session_charset->number);
 
429
      int2store(pos, cs->number);
537
430
      /*
538
431
        For TEXT/BLOB columns, field_length describes the maximum data
539
432
        length in bytes. There is no limit to the number of characters
545
438
        of characters here is limited by the column definition.
546
439
      */
547
440
      max_char_len= field.length / item->collation.collation->mbmaxlen;
548
 
      int4store(pos+2, max_char_len * session_charset->mbmaxlen);
 
441
      int4store(pos+2, max_char_len * cs->mbmaxlen);
549
442
    }
550
443
    pos[6]= field.type;
551
444
    int2store(pos+7,field.flags);
552
445
    pos[9]= (char) field.decimals;
553
 
    pos[10]= 0;                         // For the future
554
 
    pos[11]= 0;                         // For the future
 
446
    pos[10]= 0;                // For the future
 
447
    pos[11]= 0;                // For the future
555
448
    pos+= 12;
556
449
 
557
 
    local_packet->length((uint) (pos - local_packet->ptr()));
 
450
    packet->length((uint32_t) (pos - packet->ptr()));
558
451
    if (flags & SEND_DEFAULTS)
559
 
      item->send(&prot, &tmp);                  // Send default value
560
 
    if (prot.write())
561
 
      break;                                    /* purecov: inspected */
 
452
      item->send(this, &tmp);            // Send default value
 
453
    if (write())
 
454
      break;                    /* purecov: inspected */
562
455
  }
563
456
 
564
457
  if (flags & SEND_EOF)
568
461
      to show that there is no cursor.
569
462
      Send no warning information, as it will be sent at statement end.
570
463
    */
571
 
    write_eof_packet(session, &session->net, session->server_status, session->total_warn_count);
 
464
    write_eof_packet(session, &net, session->server_status, session->total_warn_count);
572
465
  }
573
 
  return(prepare_for_send(list));
 
466
 
 
467
  field_count= list->elements;
 
468
  return 0;
574
469
 
575
470
err:
576
471
  my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES),
577
 
             MYF(0));   /* purecov: inspected */
578
 
  return(1);                            /* purecov: inspected */
 
472
             MYF(0));    /* purecov: inspected */
 
473
  return 1;                /* purecov: inspected */
579
474
}
580
475
 
581
476
 
582
 
bool Protocol::write()
 
477
bool ProtocolOldLibdrizzle::write()
583
478
{
584
 
  return(my_net_write(&session->net, (unsigned char*) packet->ptr(),
 
479
  return(drizzleclient_net_write(&net, (unsigned char*) packet->ptr(),
585
480
                           packet->length()));
586
481
}
587
482
 
588
 
 
589
 
/**
590
 
  Send \\0 end terminated string.
591
 
 
592
 
  @param from   NULL or \\0 terminated string
593
 
 
594
 
  @note
595
 
    In most cases one should use store(from, length) instead of this function
596
 
 
597
 
  @retval
598
 
    0           ok
599
 
  @retval
600
 
    1           error
601
 
*/
602
 
 
603
 
bool Protocol::store(const char *from, const CHARSET_INFO * const cs)
604
 
{
605
 
  if (!from)
606
 
    return store_null();
607
 
  uint32_t length= strlen(from);
608
 
  return store(from, length, cs);
609
 
}
610
 
 
611
 
 
612
 
/**
613
 
  Send a set of strings as one long string with ',' in between.
614
 
*/
615
 
 
616
 
bool Protocol::store(I_List<i_string>* str_list)
617
 
{
618
 
  char buf[256];
619
 
  String tmp(buf, sizeof(buf), &my_charset_bin);
620
 
  uint32_t len;
621
 
  I_List_iterator<i_string> it(*str_list);
622
 
  i_string* s;
623
 
 
624
 
  tmp.length(0);
625
 
  while ((s=it++))
626
 
  {
627
 
    tmp.append(s->ptr);
628
 
    tmp.append(',');
629
 
  }
630
 
  if ((len= tmp.length()))
631
 
    len--;                                      // Remove last ','
632
 
  return store((char*) tmp.ptr(), len,  tmp.charset());
633
 
}
634
 
 
635
 
 
636
 
bool Protocol::store(String *str)
637
 
{
638
 
  return store((char*) str->ptr(), str->length(), str->charset());
639
 
}
640
 
 
641
 
void Protocol::free()
 
483
void ProtocolOldLibdrizzle::free()
642
484
{
643
485
  packet->free();
644
486
}
645
487
 
646
488
 
647
 
/****************************************************************************
648
 
  Functions to handle the simple (default) protocol where everything is
649
 
  This protocol is the one that is used by default between the MySQL server
650
 
  and client when you are not using prepared statements.
651
 
 
652
 
  All data are sent as 'packed-string-length' followed by 'string-data'
653
 
****************************************************************************/
654
 
 
655
 
void Protocol_text::prepare_for_resend()
 
489
void ProtocolOldLibdrizzle::setRandom(uint64_t seed1, uint64_t seed2)
 
490
{
 
491
  drizzleclient_randominit(&rand, seed1, seed2);
 
492
}
 
493
 
 
494
bool ProtocolOldLibdrizzle::setFileDescriptor(int fd)
 
495
{
 
496
  if (drizzleclient_net_init_sock(&net, fd, 0))
 
497
    return true;
 
498
  return false;
 
499
}
 
500
 
 
501
int ProtocolOldLibdrizzle::fileDescriptor(void)
 
502
{
 
503
  return drizzleclient_net_get_sd(&net);
 
504
}
 
505
 
 
506
bool ProtocolOldLibdrizzle::authenticate()
 
507
{
 
508
  bool connection_is_valid;
 
509
 
 
510
  /* Use "connect_timeout" value during connection phase */
 
511
  drizzleclient_net_set_read_timeout(&net, connect_timeout);
 
512
  drizzleclient_net_set_write_timeout(&net, connect_timeout);
 
513
 
 
514
  connection_is_valid= checkConnection();
 
515
 
 
516
  if (connection_is_valid)
 
517
    sendOK();
 
518
  else
 
519
  {
 
520
    sendError(session->main_da.sql_errno(), session->main_da.message());
 
521
    return false;
 
522
  }
 
523
 
 
524
  /* Connect completed, set read/write timeouts back to default */
 
525
  drizzleclient_net_set_read_timeout(&net,
 
526
                                     session->variables.net_read_timeout);
 
527
  drizzleclient_net_set_write_timeout(&net,
 
528
                                      session->variables.net_write_timeout);
 
529
  return true;
 
530
}
 
531
 
 
532
bool ProtocolOldLibdrizzle::readCommand(char **l_packet, uint32_t *packet_length)
 
533
{
 
534
  /*
 
535
    This thread will do a blocking read from the client which
 
536
    will be interrupted when the next command is received from
 
537
    the client, the connection is closed or "net_wait_timeout"
 
538
    number of seconds has passed
 
539
  */
 
540
#ifdef NEVER
 
541
  /* We can do this much more efficiently with poll timeouts or watcher thread,
 
542
     disabling for now, which means net_wait_timeout == read_timeout. */
 
543
  drizzleclient_net_set_read_timeout(&net,
 
544
                                     session->variables.net_wait_timeout);
 
545
#endif
 
546
 
 
547
  session->clear_error();
 
548
  session->main_da.reset_diagnostics_area();
 
549
 
 
550
  net.pkt_nr=0;
 
551
 
 
552
  *packet_length= drizzleclient_net_read(&net);
 
553
  if (*packet_length == packet_error)
 
554
  {
 
555
    /* Check if we can continue without closing the connection */
 
556
 
 
557
    if(net.last_errno== CR_NET_PACKET_TOO_LARGE)
 
558
      my_error(ER_NET_PACKET_TOO_LARGE, MYF(0));
 
559
    if (session->main_da.status() == Diagnostics_area::DA_ERROR)
 
560
      sendError(session->main_da.sql_errno(), session->main_da.message());
 
561
    else
 
562
      session->protocol->sendOK();
 
563
 
 
564
    if (net.error != 3)
 
565
      return false;                       // We have to close it.
 
566
 
 
567
    net.error= 0;
 
568
    *packet_length= 0;
 
569
    return true;
 
570
  }
 
571
 
 
572
  *l_packet= (char*) net.read_pos;
 
573
 
 
574
  /*
 
575
    'packet_length' contains length of data, as it was stored in packet
 
576
    header. In case of malformed header, drizzleclient_net_read returns zero.
 
577
    If packet_length is not zero, drizzleclient_net_read ensures that the returned
 
578
    number of bytes was actually read from network.
 
579
    There is also an extra safety measure in drizzleclient_net_read:
 
580
    it sets packet[packet_length]= 0, but only for non-zero packets.
 
581
  */
 
582
 
 
583
  if (*packet_length == 0)                       /* safety */
 
584
  {
 
585
    /* Initialize with COM_SLEEP packet */
 
586
    (*l_packet)[0]= (unsigned char) COM_SLEEP;
 
587
    *packet_length= 1;
 
588
  }
 
589
  /* Do not rely on drizzleclient_net_read, extra safety against programming errors. */
 
590
  (*l_packet)[*packet_length]= '\0';                  /* safety */
 
591
 
 
592
#ifdef NEVER
 
593
  /* See comment above. */
 
594
  /* Restore read timeout value */
 
595
  drizzleclient_net_set_read_timeout(&net,
 
596
                                     session->variables.net_read_timeout);
 
597
#endif
 
598
 
 
599
  return true;
 
600
}
 
601
 
 
602
void ProtocolOldLibdrizzle::close(void)
 
603
{
 
604
  if (net.vio)
 
605
  { 
 
606
    drizzleclient_net_close(&net);
 
607
    drizzleclient_net_end(&net);
 
608
  }
 
609
}
 
610
 
 
611
void ProtocolOldLibdrizzle::forceClose(void)
 
612
{
 
613
  if (net.vio)
 
614
    drizzleclient_vio_close(net.vio);
 
615
}
 
616
 
 
617
void ProtocolOldLibdrizzle::prepareForResend()
656
618
{
657
619
  packet->length(0);
658
620
}
659
621
 
660
 
bool Protocol_text::store_null()
 
622
bool ProtocolOldLibdrizzle::store(void)
661
623
{
662
624
  char buff[1];
663
625
  buff[0]= (char)251;
670
632
  and store in network buffer.
671
633
*/
672
634
 
673
 
bool Protocol::store_string_aux(const char *from, size_t length,
674
 
                                const CHARSET_INFO * const fromcs,
675
 
                                                                const CHARSET_INFO * const tocs)
 
635
bool ProtocolOldLibdrizzle::storeString(const char *from, size_t length,
 
636
                                        const CHARSET_INFO * const fromcs,
 
637
                                        const CHARSET_INFO * const tocs)
676
638
{
677
639
  /* 'tocs' is set 0 when client issues SET character_set_results=NULL */
678
640
  if (tocs && !my_charset_same(fromcs, tocs) &&
680
642
      tocs != &my_charset_bin)
681
643
  {
682
644
    /* Store with conversion */
683
 
    return net_store_data((unsigned char*) from, length, fromcs, tocs);
 
645
    return netStoreData((unsigned char*) from, length, fromcs, tocs);
684
646
  }
685
647
  /* Store without conversion */
686
 
  return net_store_data((unsigned char*) from, length);
687
 
}
688
 
 
689
 
 
690
 
bool Protocol_text::store(const char *from, size_t length,
691
 
                          const CHARSET_INFO * const fromcs,
692
 
                                                  const CHARSET_INFO * const tocs)
693
 
{
694
 
  return store_string_aux(from, length, fromcs, tocs);
695
 
}
696
 
 
697
 
 
698
 
bool Protocol_text::store(const char *from, size_t length,
 
648
  return netStoreData((unsigned char*) from, length);
 
649
}
 
650
 
 
651
 
 
652
bool ProtocolOldLibdrizzle::store(const char *from, size_t length,
699
653
                          const CHARSET_INFO * const fromcs)
700
654
{
701
 
  const CHARSET_INFO * const tocs= this->session->variables.character_set_results;
702
 
  return store_string_aux(from, length, fromcs, tocs);
703
 
}
704
 
 
705
 
 
706
 
bool Protocol_text::store_tiny(int64_t from)
707
 
{
708
 
  char buff[20];
709
 
  return net_store_data((unsigned char*) buff,
710
 
                        (size_t) (int10_to_str((int) from, buff, -10) - buff));
711
 
}
712
 
 
713
 
 
714
 
bool Protocol_text::store_short(int64_t from)
715
 
{
716
 
  char buff[20];
717
 
  return net_store_data((unsigned char*) buff,
718
 
                        (size_t) (int10_to_str((int) from, buff, -10) -
719
 
                                  buff));
720
 
}
721
 
 
722
 
 
723
 
bool Protocol_text::store_long(int64_t from)
724
 
{
725
 
  char buff[20];
726
 
  return net_store_data((unsigned char*) buff,
727
 
                        (size_t) (int10_to_str((long int)from, buff,
728
 
                                               (from <0)?-10:10)-buff));
729
 
}
730
 
 
731
 
 
732
 
bool Protocol_text::store_int64_t(int64_t from, bool unsigned_flag)
 
655
  const CHARSET_INFO * const tocs= default_charset_info;
 
656
  return storeString(from, length, fromcs, tocs);
 
657
}
 
658
 
 
659
 
 
660
bool ProtocolOldLibdrizzle::store(int32_t from)
 
661
{
 
662
  char buff[12];
 
663
  return netStoreData((unsigned char*) buff,
 
664
                      (size_t) (int10_to_str(from, buff, -10) - buff));
 
665
}
 
666
 
 
667
bool ProtocolOldLibdrizzle::store(uint32_t from)
 
668
{
 
669
  char buff[11];
 
670
  return netStoreData((unsigned char*) buff,
 
671
                      (size_t) (int10_to_str(from, buff, 10) - buff));
 
672
}
 
673
 
 
674
bool ProtocolOldLibdrizzle::store(int64_t from)
733
675
{
734
676
  char buff[22];
735
 
  return net_store_data((unsigned char*) buff,
736
 
                        (size_t) (int64_t10_to_str(from,buff,
737
 
                                                    unsigned_flag ? 10 : -10)-
738
 
                                  buff));
739
 
}
740
 
 
741
 
 
742
 
bool Protocol_text::store_decimal(const my_decimal *d)
743
 
{
744
 
  char buff[DECIMAL_MAX_STR_LENGTH];
745
 
  String str(buff, sizeof(buff), &my_charset_bin);
746
 
  (void) my_decimal2string(E_DEC_FATAL_ERROR, d, 0, 0, 0, &str);
747
 
  return net_store_data((unsigned char*) str.ptr(), str.length());
748
 
}
749
 
 
750
 
 
751
 
bool Protocol_text::store(float from, uint32_t decimals, String *buffer)
752
 
{
753
 
  buffer->set_real((double) from, decimals, session->charset());
754
 
  return net_store_data((unsigned char*) buffer->ptr(), buffer->length());
755
 
}
756
 
 
757
 
 
758
 
bool Protocol_text::store(double from, uint32_t decimals, String *buffer)
 
677
  return netStoreData((unsigned char*) buff,
 
678
                      (size_t) (int64_t10_to_str(from, buff, -10) - buff));
 
679
}
 
680
 
 
681
bool ProtocolOldLibdrizzle::store(uint64_t from)
 
682
{
 
683
  char buff[21];
 
684
  return netStoreData((unsigned char*) buff,
 
685
                      (size_t) (int64_t10_to_str(from, buff, 10) - buff));
 
686
}
 
687
 
 
688
 
 
689
bool ProtocolOldLibdrizzle::store(double from, uint32_t decimals, String *buffer)
759
690
{
760
691
  buffer->set_real(from, decimals, session->charset());
761
 
  return net_store_data((unsigned char*) buffer->ptr(), buffer->length());
 
692
  return netStoreData((unsigned char*) buffer->ptr(), buffer->length());
762
693
}
763
694
 
764
695
 
765
 
bool Protocol_text::store(Field *field)
 
696
bool ProtocolOldLibdrizzle::store(Field *from)
766
697
{
767
 
  if (field->is_null())
768
 
    return store_null();
 
698
  if (from->is_null())
 
699
    return store();
769
700
  char buff[MAX_FIELD_WIDTH];
770
701
  String str(buff,sizeof(buff), &my_charset_bin);
771
 
  const CHARSET_INFO * const tocs= this->session->variables.character_set_results;
772
 
 
773
 
  field->val_str(&str);
774
 
 
775
 
  return store_string_aux(str.ptr(), str.length(), str.charset(), tocs);
 
702
  const CHARSET_INFO * const tocs= default_charset_info;
 
703
 
 
704
  from->val_str(&str);
 
705
 
 
706
  return storeString(str.ptr(), str.length(), str.charset(), tocs);
776
707
}
777
708
 
778
709
 
779
710
/**
780
711
  @todo
781
 
    Second_part format ("%06") needs to change when 
782
 
    we support 0-6 decimals for time.
783
 
*/
784
 
 
785
 
bool Protocol_text::store(DRIZZLE_TIME *tm)
786
 
{
787
 
  char buff[40];
788
 
  uint32_t length;
789
 
  length= sprintf(buff, "%04d-%02d-%02d %02d:%02d:%02d",
790
 
                           (int) tm->year,
791
 
                           (int) tm->month,
792
 
                           (int) tm->day,
793
 
                           (int) tm->hour,
794
 
                           (int) tm->minute,
795
 
                           (int) tm->second);
796
 
  if (tm->second_part)
797
 
    length+= sprintf(buff+length, ".%06d",
798
 
                                     (int)tm->second_part);
799
 
  return net_store_data((unsigned char*) buff, length);
800
 
}
801
 
 
802
 
 
803
 
bool Protocol_text::store_date(DRIZZLE_TIME *tm)
804
 
{
805
 
  char buff[MAX_DATE_STRING_REP_LENGTH];
806
 
  size_t length= my_date_to_str(tm, buff);
807
 
  return net_store_data((unsigned char*) buff, length);
808
 
}
809
 
 
810
 
 
811
 
/**
812
 
  @todo 
813
 
    Second_part format ("%06") needs to change when 
814
 
    we support 0-6 decimals for time.
815
 
*/
816
 
 
817
 
bool Protocol_text::store_time(DRIZZLE_TIME *tm)
818
 
{
819
 
  char buff[40];
820
 
  uint32_t length;
821
 
  uint32_t day= (tm->year || tm->month) ? 0 : tm->day;
822
 
  length= sprintf(buff, "%s%02ld:%02d:%02d",
823
 
                           tm->neg ? "-" : "",
824
 
                           (long) day*24L+(long) tm->hour,
825
 
                           (int) tm->minute,
826
 
                           (int) tm->second);
827
 
  if (tm->second_part)
828
 
    length+= sprintf(buff+length, ".%06d", (int)tm->second_part);
829
 
  return net_store_data((unsigned char*) buff, length);
830
 
}
831
 
 
 
712
    Second_part format ("%06") needs to change when
 
713
    we support 0-6 decimals for time.
 
714
*/
 
715
 
 
716
bool ProtocolOldLibdrizzle::store(const DRIZZLE_TIME *tm)
 
717
{
 
718
  char buff[40];
 
719
  uint32_t length;
 
720
  uint32_t day;
 
721
 
 
722
  switch (tm->time_type)
 
723
  {
 
724
  case DRIZZLE_TIMESTAMP_DATETIME:
 
725
    length= sprintf(buff, "%04d-%02d-%02d %02d:%02d:%02d",
 
726
                    (int) tm->year,
 
727
                    (int) tm->month,
 
728
                    (int) tm->day,
 
729
                    (int) tm->hour,
 
730
                    (int) tm->minute,
 
731
                    (int) tm->second);
 
732
    if (tm->second_part)
 
733
      length+= sprintf(buff+length, ".%06d", (int)tm->second_part);
 
734
    break;
 
735
 
 
736
  case DRIZZLE_TIMESTAMP_DATE:
 
737
    length= sprintf(buff, "%04d-%02d-%02d",
 
738
                    (int) tm->year,
 
739
                    (int) tm->month,
 
740
                    (int) tm->day);
 
741
    break;
 
742
 
 
743
  case DRIZZLE_TIMESTAMP_TIME:
 
744
    day= (tm->year || tm->month) ? 0 : tm->day;
 
745
    length= sprintf(buff, "%s%02ld:%02d:%02d", tm->neg ? "-" : "",
 
746
                    (long) day*24L+(long) tm->hour, (int) tm->minute,
 
747
                    (int) tm->second);
 
748
    if (tm->second_part)
 
749
      length+= sprintf(buff+length, ".%06d", (int)tm->second_part);
 
750
    break;
 
751
 
 
752
  case DRIZZLE_TIMESTAMP_NONE:
 
753
  case DRIZZLE_TIMESTAMP_ERROR:
 
754
  default:
 
755
    assert(0);
 
756
    return false;
 
757
  }
 
758
 
 
759
  return netStoreData((unsigned char*) buff, length);
 
760
}
 
761
 
 
762
bool ProtocolOldLibdrizzle::checkConnection(void)
 
763
{
 
764
  uint32_t pkt_len= 0;
 
765
  char *end;
 
766
 
 
767
  // TCP/IP connection
 
768
  {
 
769
    char ip[NI_MAXHOST];
 
770
 
 
771
    if (drizzleclient_net_peer_addr(&net, ip, &session->peer_port, NI_MAXHOST))
 
772
    {
 
773
      my_error(ER_BAD_HOST_ERROR, MYF(0), session->security_ctx.ip.c_str());
 
774
      return false;
 
775
    }
 
776
 
 
777
    session->security_ctx.ip.assign(ip);
 
778
  }
 
779
  drizzleclient_net_keepalive(&net, true);
 
780
 
 
781
  uint32_t server_capabilites;
 
782
  {
 
783
    /* buff[] needs to big enough to hold the server_version variable */
 
784
    char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH + 64];
 
785
 
 
786
    server_capabilites= CLIENT_BASIC_FLAGS;
 
787
 
 
788
#ifdef HAVE_COMPRESS
 
789
    server_capabilites|= CLIENT_COMPRESS;
 
790
#endif /* HAVE_COMPRESS */
 
791
 
 
792
    end= buff + strlen(server_version);
 
793
    if ((end - buff) >= SERVER_VERSION_LENGTH)
 
794
      end= buff + (SERVER_VERSION_LENGTH - 1);
 
795
    memcpy(buff, server_version, end - buff);
 
796
    *end= 0;
 
797
    end++;
 
798
 
 
799
    int4store((unsigned char*) end, thread_id);
 
800
    end+= 4;
 
801
    /*
 
802
      So as _checkConnection is the only entry point to authorization
 
803
      procedure, scramble is set here. This gives us new scramble for
 
804
      each handshake.
 
805
    */
 
806
    drizzleclient_create_random_string(scramble, SCRAMBLE_LENGTH, &rand);
 
807
    /*
 
808
      Old clients does not understand long scrambles, but can ignore packet
 
809
      tail: that's why first part of the scramble is placed here, and second
 
810
      part at the end of packet.
 
811
    */
 
812
    end= strncpy(end, scramble, SCRAMBLE_LENGTH_323);
 
813
    end+= SCRAMBLE_LENGTH_323;
 
814
 
 
815
    *end++= 0; /* an empty byte for some reason */
 
816
 
 
817
    int2store(end, server_capabilites);
 
818
    /* write server characteristics: up to 16 bytes allowed */
 
819
    end[2]=(char) default_charset_info->number;
 
820
    int2store(end+3, session->server_status);
 
821
    memset(end+5, 0, 13);
 
822
    end+= 18;
 
823
    /* write scramble tail */
 
824
    size_t scramble_len= SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323;
 
825
    end= strncpy(end, scramble + SCRAMBLE_LENGTH_323, scramble_len);
 
826
    end+= scramble_len;
 
827
 
 
828
    *end++= 0; /* an empty byte for some reason */
 
829
 
 
830
    /* At this point we write connection message and read reply */
 
831
    if (drizzleclient_net_write_command(&net
 
832
          , (unsigned char) protocol_version
 
833
          , (unsigned char*) ""
 
834
          , 0
 
835
          , (unsigned char*) buff
 
836
          , (size_t) (end-buff)) 
 
837
        ||    (pkt_len= drizzleclient_net_read(&net)) == packet_error 
 
838
        || pkt_len < MIN_HANDSHAKE_SIZE)
 
839
    {
 
840
      my_error(ER_HANDSHAKE_ERROR, MYF(0), session->security_ctx.ip.c_str());
 
841
      return false;
 
842
    }
 
843
  }
 
844
  if (session->packet.alloc(session->variables.net_buffer_length))
 
845
    return false; /* The error is set by alloc(). */
 
846
 
 
847
  session->client_capabilities= uint2korr(net.read_pos);
 
848
 
 
849
 
 
850
  session->client_capabilities|= ((uint32_t) uint2korr(net.read_pos + 2)) << 16;
 
851
  session->max_client_packet_length= uint4korr(net.read_pos + 4);
 
852
  session->update_charset();
 
853
  end= (char*) net.read_pos + 32;
 
854
 
 
855
  /*
 
856
    Disable those bits which are not supported by the server.
 
857
    This is a precautionary measure, if the client lies. See Bug#27944.
 
858
  */
 
859
  session->client_capabilities&= server_capabilites;
 
860
 
 
861
  if (end >= (char*) net.read_pos + pkt_len + 2)
 
862
  {
 
863
    my_error(ER_HANDSHAKE_ERROR, MYF(0), session->security_ctx.ip.c_str());
 
864
    return false;
 
865
  }
 
866
 
 
867
  net.return_status= &session->server_status;
 
868
 
 
869
  char *user= end;
 
870
  char *passwd= strchr(user, '\0')+1;
 
871
  uint32_t user_len= passwd - user - 1;
 
872
  char *l_db= passwd;
 
873
  char db_buff[NAME_LEN + 1];           // buffer to store db in utf8
 
874
  char user_buff[USERNAME_LENGTH + 1];    // buffer to store user in utf8
 
875
  uint32_t dummy_errors;
 
876
 
 
877
  /*
 
878
    Old clients send null-terminated string as password; new clients send
 
879
    the size (1 byte) + string (not null-terminated). Hence in case of empty
 
880
    password both send '\0'.
 
881
 
 
882
    This strlen() can't be easily deleted without changing protocol.
 
883
 
 
884
    Cast *passwd to an unsigned char, so that it doesn't extend the sign for
 
885
    *passwd > 127 and become 2**32-127+ after casting to uint.
 
886
  */
 
887
  uint32_t passwd_len= session->client_capabilities & CLIENT_SECURE_CONNECTION ?
 
888
    (unsigned char)(*passwd++) : strlen(passwd);
 
889
  l_db= session->client_capabilities & CLIENT_CONNECT_WITH_DB ? l_db + passwd_len + 1 : 0;
 
890
 
 
891
  /* strlen() can't be easily deleted without changing protocol */
 
892
  uint32_t db_len= l_db ? strlen(l_db) : 0;
 
893
 
 
894
  if (passwd + passwd_len + db_len > (char *) net.read_pos + pkt_len)
 
895
  {
 
896
    my_error(ER_HANDSHAKE_ERROR, MYF(0), session->security_ctx.ip.c_str());
 
897
    return false;
 
898
  }
 
899
 
 
900
  /* Since 4.1 all database names are stored in utf8 */
 
901
  if (l_db)
 
902
  {
 
903
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
 
904
                             system_charset_info,
 
905
                             l_db, db_len,
 
906
                             session->charset(), &dummy_errors)]= 0;
 
907
    l_db= db_buff;
 
908
  }
 
909
 
 
910
  user_buff[user_len= copy_and_convert(user_buff, sizeof(user_buff)-1,
 
911
                                       system_charset_info, user, user_len,
 
912
                                       session->charset(), &dummy_errors)]= '\0';
 
913
  user= user_buff;
 
914
 
 
915
  /* If username starts and ends in "'", chop them off */
 
916
  if (user_len > 1 && user[0] == '\'' && user[user_len - 1] == '\'')
 
917
  {
 
918
    user[user_len-1]= 0;
 
919
    user++;
 
920
    user_len-= 2;
 
921
  }
 
922
 
 
923
  session->security_ctx.user.assign(user);
 
924
 
 
925
  return session->checkUser(passwd, passwd_len, l_db);
 
926
}
 
927
 
 
928
static ProtocolFactoryOldLibdrizzle *factory= NULL;
 
929
 
 
930
static int init(PluginRegistry &registry)
 
931
{
 
932
  factory= new ProtocolFactoryOldLibdrizzle;
 
933
  registry.add(factory); 
 
934
  return 0;
 
935
}
 
936
 
 
937
static int deinit(PluginRegistry &registry)
 
938
{
 
939
  if (factory)
 
940
  {
 
941
    registry.remove(factory);
 
942
    delete factory;
 
943
  }
 
944
  return 0;
 
945
}
 
946
 
 
947
drizzle_declare_plugin(oldlibdrizzle)
 
948
{
 
949
  "oldlibdrizzle",
 
950
  "0.1",
 
951
  "Eric Day",
 
952
  "Old libdrizzle Protocol",
 
953
  PLUGIN_LICENSE_GPL,
 
954
  init,   /* Plugin Init */
 
955
  deinit, /* Plugin Deinit */
 
956
  NULL,   /* status variables */
 
957
  NULL,   /* system variables */
 
958
  NULL    /* config options */
 
959
}
 
960
drizzle_declare_plugin_end;