← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/drizzle_protocol/net_serv.cc

  • Committer: Brian Aker
  • Date: 2010-02-07 01:33:54 UTC
  • Revision ID: brian@gaz-20100207013354-d2pg1n68u5c09pgo
Remove giant include header to its own file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/drizzle_protocol/net_serv.cc
1
 
/* Copyright (C) 2000 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 */
15
 
 
16
 
/*
17
 
  HFTODO this must be hidden if we don't want client capabilities in 
18
 
  embedded library
 
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; 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
19
19
 */
20
 
#include <drizzled/global.h>
21
 
#include <drizzle.h>
22
 
#include <drizzled/error.h>
23
 
#include <mysys/my_sys.h>
24
 
#include <vio/violite.h>
 
20
 
 
21
#include "config.h"
 
22
#include <drizzled/session.h>
 
23
 
 
24
#include <assert.h>
 
25
#include <stdio.h>
 
26
#include <stdlib.h>
 
27
#include <string.h>
25
28
#include <signal.h>
26
29
#include <errno.h>
 
30
#include <sys/socket.h>
27
31
#include <sys/poll.h>
 
32
#include <zlib.h>
 
33
#include <algorithm>
 
34
 
 
35
#include "errmsg.h"
 
36
#include "vio.h"
 
37
#include "net_serv.h"
 
38
 
 
39
using namespace std;
28
40
 
29
41
/*
30
42
  The following handles the differences when this is linked between the
35
47
  can't normally do this the client should have a bigger max_allowed_packet.
36
48
*/
37
49
 
38
 
 
39
 
#define update_statistics(A)
40
 
#define thd_increment_bytes_sent(N)
41
 
 
42
 
#define TEST_BLOCKING           8
 
50
  /* Constants when using compression */
 
51
#define NET_HEADER_SIZE 4               /* standard header size */
 
52
#define COMP_HEADER_SIZE 3              /* compression header extra size */
 
53
 
43
54
#define MAX_PACKET_LENGTH (256L*256L*256L-1)
 
55
const char  *not_error_sqlstate= "00000";
44
56
 
45
57
static bool net_write_buff(NET *net, const unsigned char *packet, uint32_t len);
46
 
 
 
58
static int drizzleclient_net_real_write(NET *net, const unsigned char *packet, size_t len);
47
59
 
48
60
/** Init with packet info. */
49
61
 
50
 
bool my_net_init(NET *net, Vio* vio)
 
62
bool drizzleclient_net_init(NET *net, Vio* vio, uint32_t buffer_length)
51
63
{
52
64
  net->vio = vio;
53
 
  my_net_local_init(net);                       /* Set some limits */
54
 
  if (!(net->buff=(uchar*) my_malloc((size_t) net->max_packet+
55
 
                                     NET_HEADER_SIZE + COMP_HEADER_SIZE,
56
 
                                     MYF(MY_WME))))
 
65
  net->max_packet= (uint32_t) buffer_length;
 
66
  net->max_packet_size= max(buffer_length,
 
67
                            drizzled::global_system_variables.max_allowed_packet);
 
68
 
 
69
  if (!(net->buff=(unsigned char*) malloc((size_t) net->max_packet+
 
70
                                          NET_HEADER_SIZE + COMP_HEADER_SIZE)))
57
71
    return(1);
58
72
  net->buff_end=net->buff+net->max_packet;
59
73
  net->error=0; net->return_status=0;
65
79
  net->last_errno=0;
66
80
  net->unused= 0;
67
81
 
68
 
  if (vio != 0)                                 /* If real connection */
 
82
  if (vio != 0)                    /* If real connection */
69
83
  {
70
 
    net->fd  = vio_fd(vio);                     /* For perl DBI/DBD */
71
 
    vio_fastsend(vio);
 
84
    net->fd  = drizzleclient_vio_fd(vio);            /* For perl DBI/DBD */
 
85
    drizzleclient_vio_fastsend(vio);
72
86
  }
73
87
  return(0);
74
88
}
75
89
 
76
 
 
77
 
void net_end(NET *net)
78
 
{
79
 
  my_free(net->buff,MYF(MY_ALLOW_ZERO_PTR));
80
 
  net->buff=0;
 
90
bool drizzleclient_net_init_sock(NET * net, int sock, int flags,
 
91
                                 uint32_t buffer_length)
 
92
{
 
93
 
 
94
  Vio *drizzleclient_vio_tmp= drizzleclient_vio_new(sock, VIO_TYPE_TCPIP, flags);
 
95
  if (drizzleclient_vio_tmp == NULL)
 
96
    return true;
 
97
  else
 
98
    if (drizzleclient_net_init(net, drizzleclient_vio_tmp, buffer_length))
 
99
    {
 
100
      /* Only delete the temporary vio if we didn't already attach it to the
 
101
       * NET object.
 
102
       */
 
103
      if (drizzleclient_vio_tmp && (net->vio != drizzleclient_vio_tmp))
 
104
        drizzleclient_vio_delete(drizzleclient_vio_tmp);
 
105
      else
 
106
      {
 
107
        (void) shutdown(sock, SHUT_RDWR);
 
108
        (void) close(sock);
 
109
      }
 
110
      return true;
 
111
    }
 
112
  return false;
 
113
}
 
114
 
 
115
void drizzleclient_net_end(NET *net)
 
116
{
 
117
  if (net->buff != NULL)
 
118
    free(net->buff);
 
119
  net->buff= NULL;
81
120
  return;
82
121
}
83
122
 
 
123
void drizzleclient_net_close(NET *net)
 
124
{
 
125
  if (net->vio != NULL)
 
126
  {
 
127
    drizzleclient_vio_delete(net->vio);
 
128
    net->vio= 0;
 
129
  }
 
130
}
 
131
 
 
132
bool drizzleclient_net_peer_addr(NET *net, char *buf, uint16_t *port, size_t buflen)
 
133
{
 
134
  return drizzleclient_vio_peer_addr(net->vio, buf, port, buflen);
 
135
}
 
136
 
 
137
void drizzleclient_net_keepalive(NET *net, bool flag)
 
138
{
 
139
  drizzleclient_vio_keepalive(net->vio, flag);
 
140
}
 
141
 
 
142
int drizzleclient_net_get_sd(NET *net)
 
143
{
 
144
  return net->vio->sd;
 
145
}
 
146
 
 
147
bool drizzleclient_net_more_data(NET *net)
 
148
{
 
149
  return (net->vio == 0 || net->vio->read_pos < net->vio->read_end);
 
150
}
84
151
 
85
152
/** Realloc the packet buffer. */
86
153
 
87
 
bool net_realloc(NET *net, size_t length)
 
154
static bool drizzleclient_net_realloc(NET *net, size_t length)
88
155
{
89
 
  uchar *buff;
 
156
  unsigned char *buff;
90
157
  size_t pkt_length;
91
158
 
92
159
  if (length >= net->max_packet_size)
93
160
  {
94
161
    /* @todo: 1 and 2 codes are identical. */
95
162
    net->error= 1;
96
 
    net->last_errno= ER_NET_PACKET_TOO_LARGE;
 
163
    net->last_errno= CR_NET_PACKET_TOO_LARGE;
97
164
    return(1);
98
165
  }
99
 
  pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1); 
 
166
  pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1);
100
167
  /*
101
168
    We must allocate some extra bytes for the end 0 and to be able to
102
169
    read big compressed blocks
103
170
  */
104
 
  if (!(buff= (uchar*) my_realloc((char*) net->buff, pkt_length +
105
 
                                  NET_HEADER_SIZE + COMP_HEADER_SIZE,
106
 
                                  MYF(MY_WME))))
 
171
  if (!(buff= (unsigned char*) realloc((char*) net->buff, pkt_length +
 
172
                               NET_HEADER_SIZE + COMP_HEADER_SIZE)))
107
173
  {
108
174
    /* @todo: 1 and 2 codes are identical. */
109
175
    net->error= 1;
110
 
    net->last_errno= ER_OUT_OF_RESOURCES;
 
176
    net->last_errno= CR_OUT_OF_MEMORY;
111
177
    /* In the server the error is reported by MY_WME flag. */
112
178
    return(1);
113
179
  }
118
184
 
119
185
 
120
186
/**
121
 
  Check if there is any data to be read from the socket.
122
 
 
123
 
  @param sd   socket descriptor
124
 
 
125
 
  @retval
126
 
    0  No data to read
127
 
  @retval
128
 
    1  Data or EOF to read
129
 
  @retval
130
 
    -1   Don't know if data is ready or not
 
187
   Check if there is any data to be read from the socket.
 
188
 
 
189
   @param sd   socket descriptor
 
190
 
 
191
   @retval
 
192
   0  No data to read
 
193
   @retval
 
194
   1  Data or EOF to read
 
195
   @retval
 
196
   -1   Don't know if data is ready or not
131
197
*/
132
198
 
133
199
static bool net_data_is_ready(int sd)
145
211
}
146
212
 
147
213
/**
148
 
  Remove unwanted characters from connection
149
 
  and check if disconnected.
150
 
 
151
 
    Read from socket until there is nothing more to read. Discard
152
 
    what is read.
153
 
 
154
 
    If there is anything when to read 'net_clear' is called this
155
 
    normally indicates an error in the protocol.
156
 
 
157
 
    When connection is properly closed (for TCP it means with
158
 
    a FIN packet), then select() considers a socket "ready to read",
159
 
    in the sense that there's EOF to read, but read() returns 0.
160
 
 
161
 
  @param net                    NET handler
162
 
  @param clear_buffer           if <> 0, then clear all data from comm buff
 
214
   Remove unwanted characters from connection
 
215
   and check if disconnected.
 
216
 
 
217
   Read from socket until there is nothing more to read. Discard
 
218
   what is read.
 
219
 
 
220
   If there is anything when to read 'drizzleclient_net_clear' is called this
 
221
   normally indicates an error in the protocol.
 
222
 
 
223
   When connection is properly closed (for TCP it means with
 
224
   a FIN packet), then select() considers a socket "ready to read",
 
225
   in the sense that there's EOF to read, but read() returns 0.
 
226
 
 
227
   @param net            NET handler
 
228
   @param clear_buffer           if <> 0, then clear all data from comm buff
163
229
*/
164
230
 
165
 
void net_clear(NET *net, bool clear_buffer)
 
231
void drizzleclient_net_clear(NET *net, bool clear_buffer)
166
232
{
167
233
  if (clear_buffer)
168
234
  {
169
235
    while (net_data_is_ready(net->vio->sd) > 0)
170
236
    {
171
237
      /* The socket is ready */
172
 
      if (vio_read(net->vio, net->buff,
173
 
                                  (size_t) net->max_packet) <= 0)
 
238
      if (drizzleclient_vio_read(net->vio, net->buff,
 
239
                   (size_t) net->max_packet) <= 0)
174
240
      {
175
241
        net->error= 2;
176
242
        break;
177
243
      }
178
244
    }
179
245
  }
180
 
  net->pkt_nr=net->compress_pkt_nr=0;           /* Ready for new command */
 
246
  net->pkt_nr=net->compress_pkt_nr=0;        /* Ready for new command */
181
247
  net->write_pos=net->buff;
182
248
  return;
183
249
}
185
251
 
186
252
/** Flush write_buffer if not empty. */
187
253
 
188
 
bool net_flush(NET *net)
 
254
bool drizzleclient_net_flush(NET *net)
189
255
{
190
256
  bool error= 0;
191
257
  if (net->buff != net->write_pos)
192
258
  {
193
 
    error=test(net_real_write(net, net->buff,
194
 
                              (size_t) (net->write_pos - net->buff)));
 
259
    error=drizzleclient_net_real_write(net, net->buff,
 
260
                         (size_t) (net->write_pos - net->buff)) ? 1 : 0;
195
261
    net->write_pos=net->buff;
196
262
  }
197
263
  /* Sync packet number if using compression */
202
268
 
203
269
 
204
270
/*****************************************************************************
205
 
** Write something to server/client buffer
206
 
*****************************************************************************/
 
271
 ** Write something to server/client buffer
 
272
 *****************************************************************************/
207
273
 
208
274
/**
209
 
  Write a logical packet with packet header.
210
 
 
211
 
  Format: Packet length (3 bytes), packet number(1 byte)
212
 
  When compression is used a 3 byte compression length is added
213
 
 
214
 
  @note
215
 
    If compression is used the original package is modified!
 
275
   Write a logical packet with packet header.
 
276
 
 
277
   Format: Packet length (3 bytes), packet number(1 byte)
 
278
   When compression is used a 3 byte compression length is added
 
279
 
 
280
   @note
 
281
   If compression is used the original package is modified!
216
282
*/
217
283
 
218
284
bool
219
 
my_net_write(NET *net,const uchar *packet,size_t len)
 
285
drizzleclient_net_write(NET *net,const unsigned char *packet,size_t len)
220
286
{
221
 
  uchar buff[NET_HEADER_SIZE];
 
287
  unsigned char buff[NET_HEADER_SIZE];
222
288
  if (unlikely(!net->vio)) /* nowhere to write */
223
289
    return 0;
224
290
  /*
230
296
  {
231
297
    const uint32_t z_size = MAX_PACKET_LENGTH;
232
298
    int3store(buff, z_size);
233
 
    buff[3]= (uchar) net->pkt_nr++;
 
299
    buff[3]= (unsigned char) net->pkt_nr++;
234
300
    if (net_write_buff(net, buff, NET_HEADER_SIZE) ||
235
 
        net_write_buff(net, packet, z_size))
 
301
        net_write_buff(net, packet, z_size))
236
302
      return 1;
237
303
    packet += z_size;
238
304
    len-=     z_size;
239
305
  }
240
306
  /* Write last packet */
241
307
  int3store(buff,len);
242
 
  buff[3]= (uchar) net->pkt_nr++;
 
308
  buff[3]= (unsigned char) net->pkt_nr++;
243
309
  if (net_write_buff(net, buff, NET_HEADER_SIZE))
244
310
    return 1;
245
 
  return test(net_write_buff(net,packet,len));
 
311
  return net_write_buff(net,packet,len) ? 1 : 0;
246
312
}
247
313
 
248
314
/**
249
 
  Send a command to the server.
250
 
 
251
 
    The reason for having both header and packet is so that libdrizzle
252
 
    can easy add a header to a special command (like prepared statements)
253
 
    without having to re-alloc the string.
254
 
 
255
 
    As the command is part of the first data packet, we have to do some data
256
 
    juggling to put the command in there, without having to create a new
257
 
    packet.
258
 
  
259
 
    This function will split big packets into sub-packets if needed.
260
 
    (Each sub packet can only be 2^24 bytes)
261
 
 
262
 
  @param net            NET handler
263
 
  @param command        Command in MySQL server (enum enum_server_command)
264
 
  @param header Header to write after command
265
 
  @param head_len       Length of header
266
 
  @param packet Query or parameter to query
267
 
  @param len            Length of packet
268
 
 
269
 
  @retval
270
 
    0   ok
271
 
  @retval
272
 
    1   error
 
315
   Send a command to the server.
 
316
 
 
317
   The reason for having both header and packet is so that libdrizzle
 
318
   can easy add a header to a special command (like prepared statements)
 
319
   without having to re-alloc the string.
 
320
 
 
321
   As the command is part of the first data packet, we have to do some data
 
322
   juggling to put the command in there, without having to create a new
 
323
   packet.
 
324
 
 
325
   This function will split big packets into sub-packets if needed.
 
326
   (Each sub packet can only be 2^24 bytes)
 
327
 
 
328
   @param net        NET handler
 
329
   @param command    Command in MySQL server (enum enum_server_command)
 
330
   @param header    Header to write after command
 
331
   @param head_len    Length of header
 
332
   @param packet    Query or parameter to query
 
333
   @param len        Length of packet
 
334
 
 
335
   @retval
 
336
   0    ok
 
337
   @retval
 
338
   1    error
273
339
*/
274
340
 
275
341
bool
276
 
net_write_command(NET *net,uchar command,
277
 
                  const uchar *header, size_t head_len,
278
 
                  const uchar *packet, size_t len)
 
342
drizzleclient_net_write_command(NET *net,unsigned char command,
 
343
                  const unsigned char *header, size_t head_len,
 
344
                  const unsigned char *packet, size_t len)
279
345
{
280
 
  uint32_t length=len+1+head_len;                       /* 1 extra byte for command */
281
 
  uchar buff[NET_HEADER_SIZE+1];
282
 
  uint header_size=NET_HEADER_SIZE+1;
 
346
  uint32_t length=len+1+head_len;            /* 1 extra byte for command */
 
347
  unsigned char buff[NET_HEADER_SIZE+1];
 
348
  uint32_t header_size=NET_HEADER_SIZE+1;
283
349
 
284
 
  buff[4]=command;                              /* For first packet */
 
350
  buff[4]=command;                /* For first packet */
285
351
 
286
352
  if (length >= MAX_PACKET_LENGTH)
287
353
  {
290
356
    do
291
357
    {
292
358
      int3store(buff, MAX_PACKET_LENGTH);
293
 
      buff[3]= (uchar) net->pkt_nr++;
 
359
      buff[3]= (unsigned char) net->pkt_nr++;
294
360
      if (net_write_buff(net, buff, header_size) ||
295
 
          net_write_buff(net, header, head_len) ||
296
 
          net_write_buff(net, packet, len))
297
 
        return(1);
 
361
          net_write_buff(net, header, head_len) ||
 
362
          net_write_buff(net, packet, len))
 
363
        return(1);
298
364
      packet+= len;
299
365
      length-= MAX_PACKET_LENGTH;
300
366
      len= MAX_PACKET_LENGTH;
301
367
      head_len= 0;
302
368
      header_size= NET_HEADER_SIZE;
303
369
    } while (length >= MAX_PACKET_LENGTH);
304
 
    len=length;                                 /* Data left to be written */
 
370
    len=length;                    /* Data left to be written */
305
371
  }
306
372
  int3store(buff,length);
307
 
  buff[3]= (uchar) net->pkt_nr++;
308
 
  return(test(net_write_buff(net, buff, header_size) ||
309
 
                   (head_len && net_write_buff(net, header, head_len)) ||
310
 
                   net_write_buff(net, packet, len) || net_flush(net)));
 
373
  buff[3]= (unsigned char) net->pkt_nr++;
 
374
  return((net_write_buff(net, buff, header_size) ||
 
375
          (head_len && net_write_buff(net, header, head_len)) ||
 
376
          net_write_buff(net, packet, len) || drizzleclient_net_flush(net)) ? 1 : 0 );
311
377
}
312
378
 
313
379
/**
314
 
  Caching the data in a local buffer before sending it.
 
380
   Caching the data in a local buffer before sending it.
315
381
 
316
382
   Fill up net->buffer and send it to the client when full.
317
383
 
318
 
    If the rest of the to-be-sent-packet is bigger than buffer,
319
 
    send it in one big block (to avoid copying to internal buffer).
320
 
    If not, copy the rest of the data to the buffer and return without
321
 
    sending data.
322
 
 
323
 
  @param net            Network handler
324
 
  @param packet Packet to send
325
 
  @param len            Length of packet
326
 
 
327
 
  @note
328
 
    The cached buffer can be sent as it is with 'net_flush()'.
329
 
    In this code we have to be careful to not send a packet longer than
330
 
    MAX_PACKET_LENGTH to net_real_write() if we are using the compressed
331
 
    protocol as we store the length of the compressed packet in 3 bytes.
332
 
 
333
 
  @retval
334
 
    0   ok
335
 
  @retval
336
 
    1
 
384
   If the rest of the to-be-sent-packet is bigger than buffer,
 
385
   send it in one big block (to avoid copying to internal buffer).
 
386
   If not, copy the rest of the data to the buffer and return without
 
387
   sending data.
 
388
 
 
389
   @param net        Network handler
 
390
   @param packet    Packet to send
 
391
   @param len        Length of packet
 
392
 
 
393
   @note
 
394
   The cached buffer can be sent as it is with 'drizzleclient_net_flush()'.
 
395
   In this code we have to be careful to not send a packet longer than
 
396
   MAX_PACKET_LENGTH to drizzleclient_net_real_write() if we are using the compressed
 
397
   protocol as we store the length of the compressed packet in 3 bytes.
 
398
 
 
399
   @retval
 
400
   0    ok
 
401
   @retval
 
402
   1
337
403
*/
338
404
 
339
405
static bool
351
417
    {
352
418
      /* Fill up already used packet and write it */
353
419
      memcpy(net->write_pos,packet,left_length);
354
 
      if (net_real_write(net, net->buff, 
355
 
                         (size_t) (net->write_pos - net->buff) + left_length))
356
 
        return 1;
 
420
      if (drizzleclient_net_real_write(net, net->buff,
 
421
                         (size_t) (net->write_pos - net->buff) + left_length))
 
422
        return 1;
357
423
      net->write_pos= net->buff;
358
424
      packet+= left_length;
359
425
      len-= left_length;
361
427
    if (net->compress)
362
428
    {
363
429
      /*
364
 
        We can't have bigger packets than 16M with compression
365
 
        Because the uncompressed length is stored in 3 bytes
 
430
        We can't have bigger packets than 16M with compression
 
431
        Because the uncompressed length is stored in 3 bytes
366
432
      */
367
433
      left_length= MAX_PACKET_LENGTH;
368
434
      while (len > left_length)
369
435
      {
370
 
        if (net_real_write(net, packet, left_length))
371
 
          return 1;
372
 
        packet+= left_length;
373
 
        len-= left_length;
 
436
        if (drizzleclient_net_real_write(net, packet, left_length))
 
437
          return 1;
 
438
        packet+= left_length;
 
439
        len-= left_length;
374
440
      }
375
441
    }
376
442
    if (len > net->max_packet)
377
 
      return net_real_write(net, packet, len) ? 1 : 0;
 
443
      return drizzleclient_net_real_write(net, packet, len) ? 1 : 0;
378
444
    /* Send out rest of the blocks as full sized blocks */
379
445
  }
380
446
  memcpy(net->write_pos,packet,len);
384
450
 
385
451
 
386
452
/**
387
 
  Read and write one packet using timeouts.
388
 
  If needed, the packet is compressed before sending.
 
453
   Read and write one packet using timeouts.
 
454
   If needed, the packet is compressed before sending.
389
455
 
390
 
  @todo
391
 
    - TODO is it needed to set this variable if we have no socket
 
456
   @todo
 
457
   - TODO is it needed to set this variable if we have no socket
392
458
*/
393
459
 
394
460
/*
395
461
  TODO: rewrite this in a manner to do non-block writes. If a write can not be made, and we are
396
462
  in the server, yield to another process and come back later.
397
463
*/
398
 
int
399
 
net_real_write(NET *net,const uchar *packet, size_t len)
 
464
static int
 
465
drizzleclient_net_real_write(NET *net, const unsigned char *packet, size_t len)
400
466
{
401
467
  size_t length;
402
 
  const uchar *pos,*end;
403
 
  uint retry_count= 0;
 
468
  const unsigned char *pos, *end;
 
469
  uint32_t retry_count= 0;
404
470
 
405
471
  /* Backup of the original SO_RCVTIMEO timeout */
406
 
  struct timeval backtime;
407
 
  int error;
408
472
 
409
473
  if (net->error == 2)
410
 
    return(-1);                         /* socket can't be used */
 
474
    return(-1);                /* socket can't be used */
411
475
 
412
476
  net->reading_or_writing=2;
413
477
  if (net->compress)
414
478
  {
415
479
    size_t complen;
416
 
    uchar *b;
417
 
    const uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
418
 
    if (!(b= (uchar*) my_malloc(len + NET_HEADER_SIZE +
419
 
                                COMP_HEADER_SIZE, MYF(MY_WME))))
 
480
    unsigned char *b;
 
481
    const uint32_t header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
 
482
    if (!(b= (unsigned char*) malloc(len + NET_HEADER_SIZE +
 
483
                             COMP_HEADER_SIZE)))
420
484
    {
421
485
      net->error= 2;
422
 
      net->last_errno= ER_OUT_OF_RESOURCES;
 
486
      net->last_errno= CR_OUT_OF_MEMORY;
423
487
      /* In the server, the error is reported by MY_WME flag. */
424
488
      net->reading_or_writing= 0;
425
489
      return(1);
426
490
    }
427
491
    memcpy(b+header_length,packet,len);
428
492
 
429
 
    if (my_compress(b+header_length, &len, &complen))
 
493
    complen= len * 120 / 100 + 12;
 
494
    unsigned char * compbuf= (unsigned char *) malloc(complen);
 
495
    if (compbuf != NULL)
 
496
    {
 
497
      uLongf tmp_complen= complen;
 
498
      int res= compress((Bytef*) compbuf, &tmp_complen,
 
499
                        (Bytef*) (b+header_length),
 
500
                        len);
 
501
      complen= tmp_complen;
 
502
 
 
503
      free(compbuf);
 
504
 
 
505
      if ((res != Z_OK) || (complen >= len))
 
506
        complen= 0;
 
507
      else
 
508
      {
 
509
        size_t tmplen= complen;
 
510
        complen= len;
 
511
        len= tmplen;
 
512
      }
 
513
    }
 
514
    else
 
515
    {
430
516
      complen=0;
 
517
    }
431
518
    int3store(&b[NET_HEADER_SIZE],complen);
432
519
    int3store(b,len);
433
 
    b[3]=(uchar) (net->compress_pkt_nr++);
 
520
    b[3]=(unsigned char) (net->compress_pkt_nr++);
434
521
    len+= header_length;
435
522
    packet= b;
436
523
  }
437
524
 
438
 
  /* Check for error, currently assert */
439
 
  if (net->write_timeout)
440
 
  {
441
 
    struct timeval waittime;
442
 
    socklen_t length;
443
 
 
444
 
    waittime.tv_sec= net->write_timeout;
445
 
    waittime.tv_usec= 0;
446
 
 
447
 
    memset(&backtime, 0, sizeof(struct timeval));
448
 
    length= sizeof(struct timeval);
449
 
    error= getsockopt(net->vio->sd, SOL_SOCKET, SO_RCVTIMEO, 
450
 
                      &backtime, &length);
451
 
    if (error != 0)
452
 
    {
453
 
      perror("getsockopt");
454
 
      assert(error == 0);
455
 
    }
456
 
    error= setsockopt(net->vio->sd, SOL_SOCKET, SO_RCVTIMEO, 
457
 
                      &waittime, (socklen_t)sizeof(struct timeval));
458
 
    assert(error == 0);
459
 
  }
460
525
  pos= packet;
461
526
  end=pos+len;
462
527
  /* Loop until we have read everything */
463
528
  while (pos != end)
464
529
  {
465
 
    if ((long) (length= vio_write(net->vio,pos,(size_t) (end-pos))) <= 0)
 
530
    assert(pos);
 
531
    if ((long) (length= drizzleclient_vio_write(net->vio, pos, (size_t) (end-pos))) <= 0)
466
532
    {
467
 
      const bool interrupted= vio_should_retry(net->vio);
468
 
      /* 
469
 
        If we read 0, or we were interrupted this means that 
470
 
        we need to switch to blocking mode and wait until the timeout 
 
533
     /*
 
534
      * We could end up here with net->vio == NULL
 
535
      * See LP bug#436685
 
536
      * If that is the case, we exit the while loop
 
537
      */
 
538
      if (net->vio == NULL)
 
539
        break;
 
540
      
 
541
      const bool interrupted= drizzleclient_vio_should_retry(net->vio);
 
542
      /*
 
543
        If we read 0, or we were interrupted this means that
 
544
        we need to switch to blocking mode and wait until the timeout
471
545
        on the socket kicks in.
472
546
      */
473
547
      if ((interrupted || length == 0))
474
548
      {
475
549
        bool old_mode;
476
550
 
477
 
        while (vio_blocking(net->vio, true, &old_mode) < 0)
 
551
        while (drizzleclient_vio_blocking(net->vio, true, &old_mode) < 0)
478
552
        {
479
 
          if (vio_should_retry(net->vio) && retry_count++ < net->retry_count)
 
553
          if (drizzleclient_vio_should_retry(net->vio) && retry_count++ < net->retry_count)
480
554
            continue;
481
555
          net->error= 2;                     /* Close socket */
482
 
          net->last_errno= ER_NET_PACKET_TOO_LARGE;
 
556
          net->last_errno= CR_NET_PACKET_TOO_LARGE;
483
557
          goto end;
484
558
        }
485
559
        retry_count=0;
490
564
        if (retry_count++ < net->retry_count)
491
565
          continue;
492
566
      }
493
 
      
494
 
      if (vio_errno(net->vio) == SOCKET_EINTR)
 
567
 
 
568
      if (drizzleclient_vio_errno(net->vio) == EINTR)
495
569
      {
496
570
        continue;
497
571
      }
498
 
      net->error= 2;                            /* Close socket */
499
 
      net->last_errno= (interrupted ? ER_NET_WRITE_INTERRUPTED :
500
 
                        ER_NET_ERROR_ON_WRITE);
 
572
      net->error= 2;                /* Close socket */
 
573
      net->last_errno= (interrupted ? CR_NET_WRITE_INTERRUPTED :
 
574
                        CR_NET_ERROR_ON_WRITE);
501
575
      break;
502
576
    }
503
577
    pos+=length;
504
 
    update_statistics(thd_increment_bytes_sent(length));
505
578
  }
506
 
 end:
507
 
  if (net->compress)
508
 
    my_free((char*) packet,MYF(0));
 
579
end:
 
580
  if ((net->compress) && (packet != NULL))
 
581
    free((char*) packet);
509
582
  net->reading_or_writing=0;
510
583
 
511
 
  if (net->write_timeout)
512
 
    error= setsockopt(net->vio->sd, SOL_SOCKET, SO_RCVTIMEO, 
513
 
                      &backtime, (socklen_t)sizeof(struct timeval));
514
 
 
515
584
  return(((int) (pos != end)));
516
585
}
517
586
 
518
587
 
519
588
/**
520
 
  Reads one packet to net->buff + net->where_b.
521
 
  Long packets are handled by my_net_read().
522
 
  This function reallocates the net->buff buffer if necessary.
 
589
   Reads one packet to net->buff + net->where_b.
 
590
   Long packets are handled by drizzleclient_net_read().
 
591
   This function reallocates the net->buff buffer if necessary.
523
592
 
524
 
  @return
525
 
    Returns length of packet.
 
593
   @return
 
594
   Returns length of packet.
526
595
*/
527
596
 
528
597
static uint32_t
529
598
my_real_read(NET *net, size_t *complen)
530
599
{
531
 
  uchar *pos;
 
600
  unsigned char *pos;
532
601
  size_t length;
533
 
  uint i,retry_count=0;
534
 
  uint32_t len=packet_error;
 
602
  uint32_t i,retry_count=0;
 
603
  size_t len=packet_error;
535
604
  uint32_t remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE :
536
 
                  NET_HEADER_SIZE);
537
 
  /* Backup of the original SO_RCVTIMEO timeout */
538
 
  struct timeval backtime;
539
 
  int error= 0;
 
605
                    NET_HEADER_SIZE);
540
606
 
541
607
  *complen = 0;
542
608
 
543
609
  net->reading_or_writing= 1;
544
 
  /* Read timeout is set in my_net_set_read_timeout */
545
 
 
546
 
  pos = net->buff + net->where_b;               /* net->packet -4 */
547
 
 
548
 
 
549
 
  /* Check for error, currently assert */
550
 
  if (net->read_timeout)
551
 
  {
552
 
    struct timeval waittime;
553
 
    socklen_t length;
554
 
 
555
 
    waittime.tv_sec= net->read_timeout;
556
 
    waittime.tv_usec= 0;
557
 
 
558
 
    memset(&backtime, 0, sizeof(struct timeval));
559
 
    length= sizeof(struct timeval);
560
 
    error= getsockopt(net->vio->sd, SOL_SOCKET, SO_RCVTIMEO, 
561
 
                      &backtime, &length);
562
 
    if (error != 0)
563
 
    {
564
 
      perror("getsockopt");
565
 
      assert(error == 0);
566
 
    }
567
 
    error= setsockopt(net->vio->sd, SOL_SOCKET, SO_RCVTIMEO, 
568
 
                      &waittime, (socklen_t)sizeof(struct timeval));
569
 
    assert(error == 0);
570
 
  }
 
610
  /* Read timeout is set in drizzleclient_net_set_read_timeout */
 
611
 
 
612
  pos = net->buff + net->where_b;        /* net->packet -4 */
571
613
 
572
614
  for (i= 0; i < 2 ; i++)
573
615
  {
574
616
    while (remain > 0)
575
617
    {
576
618
      /* First read is done with non blocking mode */
577
 
      if ((long) (length= vio_read(net->vio, pos, remain)) <= 0L)
 
619
      if ((long) (length= drizzleclient_vio_read(net->vio, pos, remain)) <= 0L)
578
620
      {
579
 
        const bool interrupted = vio_should_retry(net->vio);
 
621
        if (net->vio == NULL)
 
622
          goto end;
 
623
 
 
624
        const bool interrupted = drizzleclient_vio_should_retry(net->vio);
580
625
 
581
626
        if (interrupted)
582
 
        {                                       /* Probably in MIT threads */
 
627
        {                    /* Probably in MIT threads */
583
628
          if (retry_count++ < net->retry_count)
584
629
            continue;
585
630
        }
586
 
        if (vio_errno(net->vio) == SOCKET_EINTR)
 
631
        if (drizzleclient_vio_errno(net->vio) == EINTR)
587
632
        {
588
633
          continue;
589
634
        }
590
635
        len= packet_error;
591
 
        net->error= 2;                          /* Close socket */
592
 
        net->last_errno= (vio_was_interrupted(net->vio) ?
593
 
                          ER_NET_READ_INTERRUPTED :
594
 
                          ER_NET_READ_ERROR);
595
 
        my_error(net->last_errno, MYF(0));
 
636
        net->error= 2;                /* Close socket */
 
637
        net->last_errno= (drizzleclient_vio_was_interrupted(net->vio) ?
 
638
                          CR_NET_READ_INTERRUPTED :
 
639
                          CR_NET_READ_ERROR);
 
640
        ER(net->last_errno);
596
641
        goto end;
597
642
      }
598
643
      remain -= (uint32_t) length;
599
644
      pos+= length;
600
 
      update_statistics(thd_increment_bytes_received(length));
601
645
    }
602
646
    if (i == 0)
603
 
    {                                   /* First parts is packet length */
 
647
    {                    /* First parts is packet length */
604
648
      uint32_t helping;
605
649
 
606
 
      if (net->buff[net->where_b + 3] != (uchar) net->pkt_nr)
 
650
      if (net->buff[net->where_b + 3] != (unsigned char) net->pkt_nr)
607
651
      {
608
652
        len= packet_error;
609
653
        /* Not a NET error on the client. XXX: why? */
620
664
      }
621
665
 
622
666
      len=uint3korr(net->buff+net->where_b);
623
 
      if (!len)                         /* End of big multi-packet */
 
667
      if (!len)                /* End of big multi-packet */
624
668
        goto end;
625
669
      helping = max(len,*complen) + net->where_b;
626
670
      /* The necessary size of net->buff */
627
671
      if (helping >= net->max_packet)
628
672
      {
629
 
        if (net_realloc(net,helping))
 
673
        if (drizzleclient_net_realloc(net,helping))
630
674
        {
631
675
          len= packet_error;          /* Return error and close connection */
632
676
          goto end;
638
682
  }
639
683
 
640
684
end:
641
 
  if  (net->read_timeout)
642
 
    error= setsockopt(net->vio->sd, SOL_SOCKET, SO_RCVTIMEO, 
643
 
                      &backtime, (socklen_t)sizeof(struct timeval));
644
 
  assert(error == 0);
645
685
  net->reading_or_writing= 0;
646
686
 
647
687
  return(len);
649
689
 
650
690
 
651
691
/**
652
 
  Read a packet from the client/server and return it without the internal
653
 
  package header.
654
 
 
655
 
  If the packet is the first packet of a multi-packet packet
656
 
  (which is indicated by the length of the packet = 0xffffff) then
657
 
  all sub packets are read and concatenated.
658
 
 
659
 
  If the packet was compressed, its uncompressed and the length of the
660
 
  uncompressed packet is returned.
661
 
 
662
 
  @return
663
 
  The function returns the length of the found packet or packet_error.
664
 
  net->read_pos points to the read data.
 
692
   Read a packet from the client/server and return it without the internal
 
693
   package header.
 
694
 
 
695
   If the packet is the first packet of a multi-packet packet
 
696
   (which is indicated by the length of the packet = 0xffffff) then
 
697
   all sub packets are read and concatenated.
 
698
 
 
699
   If the packet was compressed, its uncompressed and the length of the
 
700
   uncompressed packet is returned.
 
701
 
 
702
   @return
 
703
   The function returns the length of the found packet or packet_error.
 
704
   net->read_pos points to the read data.
665
705
*/
666
706
 
667
707
uint32_t
668
 
my_net_read(NET *net)
 
708
drizzleclient_net_read(NET *net)
669
709
{
670
710
  size_t len, complen;
671
711
 
679
719
      size_t total_length= 0;
680
720
      do
681
721
      {
682
 
        net->where_b += len;
683
 
        total_length += len;
684
 
        len = my_real_read(net,&complen);
 
722
        net->where_b += len;
 
723
        total_length += len;
 
724
        len = my_real_read(net,&complen);
685
725
      } while (len == MAX_PACKET_LENGTH);
686
726
      if (len != packet_error)
687
 
        len+= total_length;
 
727
        len+= total_length;
688
728
      net->where_b = save_pos;
689
729
    }
690
730
    net->read_pos = net->buff + net->where_b;
691
731
    if (len != packet_error)
692
 
      net->read_pos[len]=0;             /* Safeguard for drizzle_use_result */
 
732
      net->read_pos[len]=0;        /* Safeguard for drizzleclient_use_result */
693
733
    return len;
694
734
  }
695
735
  else
699
739
    uint32_t buf_length;
700
740
    uint32_t start_of_packet;
701
741
    uint32_t first_packet_offset;
702
 
    uint read_length, multi_byte_packet=0;
 
742
    uint32_t read_length, multi_byte_packet=0;
703
743
 
704
744
    if (net->remain_in_buf)
705
745
    {
706
 
      buf_length= net->buf_length;              /* Data left in old packet */
 
746
      buf_length= net->buf_length;        /* Data left in old packet */
707
747
      first_packet_offset= start_of_packet= (net->buf_length -
708
 
                                             net->remain_in_buf);
 
748
                                             net->remain_in_buf);
709
749
      /* Restore the character that was overwritten by the end 0 */
710
750
      net->buff[start_of_packet]= net->save_char;
711
751
    }
720
760
 
721
761
      if (buf_length - start_of_packet >= NET_HEADER_SIZE)
722
762
      {
723
 
        read_length = uint3korr(net->buff+start_of_packet);
724
 
        if (!read_length)
725
 
        { 
726
 
          /* End of multi-byte packet */
727
 
          start_of_packet += NET_HEADER_SIZE;
728
 
          break;
729
 
        }
730
 
        if (read_length + NET_HEADER_SIZE <= buf_length - start_of_packet)
731
 
        {
732
 
          if (multi_byte_packet)
733
 
          {
734
 
            /* Remove packet header for second packet */
735
 
            memmove(net->buff + first_packet_offset + start_of_packet,
736
 
                    net->buff + first_packet_offset + start_of_packet +
737
 
                    NET_HEADER_SIZE,
738
 
                    buf_length - start_of_packet);
739
 
            start_of_packet += read_length;
740
 
            buf_length -= NET_HEADER_SIZE;
741
 
          }
742
 
          else
743
 
            start_of_packet+= read_length + NET_HEADER_SIZE;
 
763
        read_length = uint3korr(net->buff+start_of_packet);
 
764
        if (!read_length)
 
765
        {
 
766
          /* End of multi-byte packet */
 
767
          start_of_packet += NET_HEADER_SIZE;
 
768
          break;
 
769
        }
 
770
        if (read_length + NET_HEADER_SIZE <= buf_length - start_of_packet)
 
771
        {
 
772
          if (multi_byte_packet)
 
773
          {
 
774
            /* Remove packet header for second packet */
 
775
            memmove(net->buff + first_packet_offset + start_of_packet,
 
776
                    net->buff + first_packet_offset + start_of_packet +
 
777
                    NET_HEADER_SIZE,
 
778
                    buf_length - start_of_packet);
 
779
            start_of_packet += read_length;
 
780
            buf_length -= NET_HEADER_SIZE;
 
781
          }
 
782
          else
 
783
            start_of_packet+= read_length + NET_HEADER_SIZE;
744
784
 
745
 
          if (read_length != MAX_PACKET_LENGTH) /* last package */
746
 
          {
747
 
            multi_byte_packet= 0;               /* No last zero len packet */
748
 
            break;
749
 
          }
750
 
          multi_byte_packet= NET_HEADER_SIZE;
751
 
          /* Move data down to read next data packet after current one */
752
 
          if (first_packet_offset)
753
 
          {
754
 
            memmove(net->buff,net->buff+first_packet_offset,
755
 
                    buf_length-first_packet_offset);
756
 
            buf_length-=first_packet_offset;
757
 
            start_of_packet -= first_packet_offset;
758
 
            first_packet_offset=0;
759
 
          }
760
 
          continue;
761
 
        }
 
785
          if (read_length != MAX_PACKET_LENGTH)    /* last package */
 
786
          {
 
787
            multi_byte_packet= 0;        /* No last zero len packet */
 
788
            break;
 
789
          }
 
790
          multi_byte_packet= NET_HEADER_SIZE;
 
791
          /* Move data down to read next data packet after current one */
 
792
          if (first_packet_offset)
 
793
          {
 
794
            memmove(net->buff,net->buff+first_packet_offset,
 
795
                    buf_length-first_packet_offset);
 
796
            buf_length-=first_packet_offset;
 
797
            start_of_packet -= first_packet_offset;
 
798
            first_packet_offset=0;
 
799
          }
 
800
          continue;
 
801
        }
762
802
      }
763
803
      /* Move data down to read next data packet after current one */
764
804
      if (first_packet_offset)
765
805
      {
766
 
        memmove(net->buff,net->buff+first_packet_offset,
767
 
                buf_length-first_packet_offset);
768
 
        buf_length-=first_packet_offset;
769
 
        start_of_packet -= first_packet_offset;
770
 
        first_packet_offset=0;
 
806
        memmove(net->buff,net->buff+first_packet_offset,
 
807
                buf_length-first_packet_offset);
 
808
        buf_length-=first_packet_offset;
 
809
        start_of_packet -= first_packet_offset;
 
810
        first_packet_offset=0;
771
811
      }
772
812
 
773
813
      net->where_b=buf_length;
774
814
      if ((packet_len = my_real_read(net,&complen)) == packet_error)
775
 
        return packet_error;
776
 
      if (my_uncompress(net->buff + net->where_b, packet_len,
777
 
                        &complen))
 
815
        return packet_error;
 
816
 
 
817
      if (complen)
778
818
      {
779
 
        net->error= 2;                  /* caller will close socket */
780
 
        net->last_errno= ER_NET_UNCOMPRESS_ERROR;
781
 
        return packet_error;
 
819
        unsigned char * compbuf= (unsigned char *) malloc(complen);
 
820
        if (compbuf != NULL)
 
821
        {
 
822
          uLongf tmp_complen= complen;
 
823
          int error= uncompress((Bytef*) compbuf, &tmp_complen,
 
824
                                (Bytef*) (net->buff + net->where_b),
 
825
                                (uLong)packet_len);
 
826
          complen= tmp_complen;
 
827
 
 
828
          if (error != Z_OK)
 
829
          {
 
830
            net->error= 2;            /* caller will close socket */
 
831
            net->last_errno= CR_NET_UNCOMPRESS_ERROR;
 
832
          }
 
833
          else
 
834
          {
 
835
            memcpy((net->buff + net->where_b), compbuf, complen);
 
836
          }
 
837
          free(compbuf);
 
838
        }
782
839
      }
783
 
      buf_length+= complen;
 
840
      else
 
841
        complen= packet_len;
 
842
 
784
843
    }
 
844
    buf_length+= complen;
785
845
 
786
846
    net->read_pos=      net->buff+ first_packet_offset + NET_HEADER_SIZE;
787
847
    net->buf_length=    buf_length;
788
848
    net->remain_in_buf= (uint32_t) (buf_length - start_of_packet);
789
849
    len = ((uint32_t) (start_of_packet - first_packet_offset) - NET_HEADER_SIZE -
790
850
           multi_byte_packet);
791
 
    net->save_char= net->read_pos[len]; /* Must be saved */
792
 
    net->read_pos[len]=0;               /* Safeguard for drizzle_use_result */
 
851
    net->save_char= net->read_pos[len];    /* Must be saved */
 
852
    net->read_pos[len]=0;        /* Safeguard for drizzleclient_use_result */
793
853
  }
794
854
  return len;
795
 
}
796
 
 
797
 
 
798
 
void my_net_set_read_timeout(NET *net, uint timeout)
 
855
  }
 
856
 
 
857
 
 
858
void drizzleclient_net_set_read_timeout(NET *net, uint32_t timeout)
799
859
{
800
860
  net->read_timeout= timeout;
 
861
#ifndef __sun
801
862
  if (net->vio)
802
 
    vio_timeout(net->vio, 0, timeout);
 
863
    drizzleclient_vio_timeout(net->vio, 0, timeout);
 
864
#endif
803
865
  return;
804
866
}
805
867
 
806
868
 
807
 
void my_net_set_write_timeout(NET *net, uint timeout)
 
869
void drizzleclient_net_set_write_timeout(NET *net, uint32_t timeout)
808
870
{
809
871
  net->write_timeout= timeout;
 
872
#ifndef __sun
810
873
  if (net->vio)
811
 
    vio_timeout(net->vio, 1, timeout);
 
874
    drizzleclient_vio_timeout(net->vio, 1, timeout);
 
875
#endif
812
876
  return;
813
877
}
 
878
/**
 
879
  Clear possible error state of struct NET
 
880
 
 
881
  @param net  clear the state of the argument
 
882
*/
 
883
 
 
884
void drizzleclient_drizzleclient_net_clear_error(NET *net)
 
885
{
 
886
  net->last_errno= 0;
 
887
  net->last_error[0]= '\0';
 
888
  strcpy(net->sqlstate, not_error_sqlstate);
 
889
}
 
890