← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/drizzle_protocol/net_serv.cc

Fixed a style variance.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/drizzle_protocol/net_serv.cc
 
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
 */
 
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>
 
28
#include <signal.h>
 
29
#include <errno.h>
 
30
#include <sys/socket.h>
 
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;
 
40
 
 
41
/*
 
42
  The following handles the differences when this is linked between the
 
43
  client and the server.
 
44
 
 
45
  This gives an error if a too big packet is found
 
46
  The server can change this with the -O switch, but because the client
 
47
  can't normally do this the client should have a bigger max_allowed_packet.
 
48
*/
 
49
 
 
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
 
 
54
#define MAX_PACKET_LENGTH (256L*256L*256L-1)
 
55
const char  *not_error_sqlstate= "00000";
 
56
 
 
57
static bool net_write_buff(NET *net, const unsigned char *packet, uint32_t len);
 
58
static int drizzleclient_net_real_write(NET *net, const unsigned char *packet, size_t len);
 
59
 
 
60
/** Init with packet info. */
 
61
 
 
62
bool drizzleclient_net_init(NET *net, Vio* vio, uint32_t buffer_length)
 
63
{
 
64
  net->vio = vio;
 
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)))
 
71
    return(1);
 
72
  net->buff_end=net->buff+net->max_packet;
 
73
  net->error=0; net->return_status=0;
 
74
  net->pkt_nr=net->compress_pkt_nr=0;
 
75
  net->write_pos=net->read_pos = net->buff;
 
76
  net->last_error[0]=0;
 
77
  net->compress=0; net->reading_or_writing=0;
 
78
  net->where_b = net->remain_in_buf=0;
 
79
  net->last_errno=0;
 
80
  net->unused= 0;
 
81
 
 
82
  if (vio != 0)                    /* If real connection */
 
83
  {
 
84
    net->fd  = drizzleclient_vio_fd(vio);            /* For perl DBI/DBD */
 
85
    drizzleclient_vio_fastsend(vio);
 
86
  }
 
87
  return(0);
 
88
}
 
89
 
 
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;
 
120
  return;
 
121
}
 
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
}
 
151
 
 
152
/** Realloc the packet buffer. */
 
153
 
 
154
static bool drizzleclient_net_realloc(NET *net, size_t length)
 
155
{
 
156
  unsigned char *buff;
 
157
  size_t pkt_length;
 
158
 
 
159
  if (length >= net->max_packet_size)
 
160
  {
 
161
    /* @todo: 1 and 2 codes are identical. */
 
162
    net->error= 1;
 
163
    net->last_errno= CR_NET_PACKET_TOO_LARGE;
 
164
    return(1);
 
165
  }
 
166
  pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1);
 
167
  /*
 
168
    We must allocate some extra bytes for the end 0 and to be able to
 
169
    read big compressed blocks
 
170
  */
 
171
  if (!(buff= (unsigned char*) realloc((char*) net->buff, pkt_length +
 
172
                               NET_HEADER_SIZE + COMP_HEADER_SIZE)))
 
173
  {
 
174
    /* @todo: 1 and 2 codes are identical. */
 
175
    net->error= 1;
 
176
    net->last_errno= CR_OUT_OF_MEMORY;
 
177
    /* In the server the error is reported by MY_WME flag. */
 
178
    return(1);
 
179
  }
 
180
  net->buff=net->write_pos=buff;
 
181
  net->buff_end=buff+(net->max_packet= (uint32_t) pkt_length);
 
182
  return(0);
 
183
}
 
184
 
 
185
 
 
186
/**
 
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
 
197
*/
 
198
 
 
199
static bool net_data_is_ready(int sd)
 
200
{
 
201
  struct pollfd ufds;
 
202
  int res;
 
203
 
 
204
  ufds.fd= sd;
 
205
  ufds.events= POLLIN | POLLPRI;
 
206
  if (!(res= poll(&ufds, 1, 0)))
 
207
    return 0;
 
208
  if (res < 0 || !(ufds.revents & (POLLIN | POLLPRI)))
 
209
    return 0;
 
210
  return 1;
 
211
}
 
212
 
 
213
/**
 
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
 
229
*/
 
230
 
 
231
void drizzleclient_net_clear(NET *net, bool clear_buffer)
 
232
{
 
233
  if (clear_buffer)
 
234
  {
 
235
    while (net_data_is_ready(net->vio->sd) > 0)
 
236
    {
 
237
      /* The socket is ready */
 
238
      if (drizzleclient_vio_read(net->vio, net->buff,
 
239
                   (size_t) net->max_packet) <= 0)
 
240
      {
 
241
        net->error= 2;
 
242
        break;
 
243
      }
 
244
    }
 
245
  }
 
246
  net->pkt_nr=net->compress_pkt_nr=0;        /* Ready for new command */
 
247
  net->write_pos=net->buff;
 
248
  return;
 
249
}
 
250
 
 
251
 
 
252
/** Flush write_buffer if not empty. */
 
253
 
 
254
bool drizzleclient_net_flush(NET *net)
 
255
{
 
256
  bool error= 0;
 
257
  if (net->buff != net->write_pos)
 
258
  {
 
259
    error=drizzleclient_net_real_write(net, net->buff,
 
260
                         (size_t) (net->write_pos - net->buff)) ? 1 : 0;
 
261
    net->write_pos=net->buff;
 
262
  }
 
263
  /* Sync packet number if using compression */
 
264
  if (net->compress)
 
265
    net->pkt_nr=net->compress_pkt_nr;
 
266
  return(error);
 
267
}
 
268
 
 
269
 
 
270
/*****************************************************************************
 
271
 ** Write something to server/client buffer
 
272
 *****************************************************************************/
 
273
 
 
274
/**
 
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!
 
282
*/
 
283
 
 
284
bool
 
285
drizzleclient_net_write(NET *net,const unsigned char *packet,size_t len)
 
286
{
 
287
  unsigned char buff[NET_HEADER_SIZE];
 
288
  if (unlikely(!net->vio)) /* nowhere to write */
 
289
    return 0;
 
290
  /*
 
291
    Big packets are handled by splitting them in packets of MAX_PACKET_LENGTH
 
292
    length. The last packet is always a packet that is < MAX_PACKET_LENGTH.
 
293
    (The last packet may even have a length of 0)
 
294
  */
 
295
  while (len >= MAX_PACKET_LENGTH)
 
296
  {
 
297
    const uint32_t z_size = MAX_PACKET_LENGTH;
 
298
    int3store(buff, z_size);
 
299
    buff[3]= (unsigned char) net->pkt_nr++;
 
300
    if (net_write_buff(net, buff, NET_HEADER_SIZE) ||
 
301
        net_write_buff(net, packet, z_size))
 
302
      return 1;
 
303
    packet += z_size;
 
304
    len-=     z_size;
 
305
  }
 
306
  /* Write last packet */
 
307
  int3store(buff,len);
 
308
  buff[3]= (unsigned char) net->pkt_nr++;
 
309
  if (net_write_buff(net, buff, NET_HEADER_SIZE))
 
310
    return 1;
 
311
  return net_write_buff(net,packet,len) ? 1 : 0;
 
312
}
 
313
 
 
314
/**
 
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
 
339
*/
 
340
 
 
341
bool
 
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)
 
345
{
 
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;
 
349
 
 
350
  buff[4]=command;                /* For first packet */
 
351
 
 
352
  if (length >= MAX_PACKET_LENGTH)
 
353
  {
 
354
    /* Take into account that we have the command in the first header */
 
355
    len= MAX_PACKET_LENGTH - 1 - head_len;
 
356
    do
 
357
    {
 
358
      int3store(buff, MAX_PACKET_LENGTH);
 
359
      buff[3]= (unsigned char) net->pkt_nr++;
 
360
      if (net_write_buff(net, buff, header_size) ||
 
361
          net_write_buff(net, header, head_len) ||
 
362
          net_write_buff(net, packet, len))
 
363
        return(1);
 
364
      packet+= len;
 
365
      length-= MAX_PACKET_LENGTH;
 
366
      len= MAX_PACKET_LENGTH;
 
367
      head_len= 0;
 
368
      header_size= NET_HEADER_SIZE;
 
369
    } while (length >= MAX_PACKET_LENGTH);
 
370
    len=length;                    /* Data left to be written */
 
371
  }
 
372
  int3store(buff,length);
 
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 );
 
377
}
 
378
 
 
379
/**
 
380
   Caching the data in a local buffer before sending it.
 
381
 
 
382
   Fill up net->buffer and send it to the client when full.
 
383
 
 
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
 
403
*/
 
404
 
 
405
static bool
 
406
net_write_buff(NET *net, const unsigned char *packet, uint32_t len)
 
407
{
 
408
  uint32_t left_length;
 
409
  if (net->compress && net->max_packet > MAX_PACKET_LENGTH)
 
410
    left_length= MAX_PACKET_LENGTH - (net->write_pos - net->buff);
 
411
  else
 
412
    left_length= (uint32_t) (net->buff_end - net->write_pos);
 
413
 
 
414
  if (len > left_length)
 
415
  {
 
416
    if (net->write_pos != net->buff)
 
417
    {
 
418
      /* Fill up already used packet and write it */
 
419
      memcpy(net->write_pos,packet,left_length);
 
420
      if (drizzleclient_net_real_write(net, net->buff,
 
421
                         (size_t) (net->write_pos - net->buff) + left_length))
 
422
        return 1;
 
423
      net->write_pos= net->buff;
 
424
      packet+= left_length;
 
425
      len-= left_length;
 
426
    }
 
427
    if (net->compress)
 
428
    {
 
429
      /*
 
430
        We can't have bigger packets than 16M with compression
 
431
        Because the uncompressed length is stored in 3 bytes
 
432
      */
 
433
      left_length= MAX_PACKET_LENGTH;
 
434
      while (len > left_length)
 
435
      {
 
436
        if (drizzleclient_net_real_write(net, packet, left_length))
 
437
          return 1;
 
438
        packet+= left_length;
 
439
        len-= left_length;
 
440
      }
 
441
    }
 
442
    if (len > net->max_packet)
 
443
      return drizzleclient_net_real_write(net, packet, len) ? 1 : 0;
 
444
    /* Send out rest of the blocks as full sized blocks */
 
445
  }
 
446
  memcpy(net->write_pos,packet,len);
 
447
  net->write_pos+= len;
 
448
  return 0;
 
449
}
 
450
 
 
451
 
 
452
/**
 
453
   Read and write one packet using timeouts.
 
454
   If needed, the packet is compressed before sending.
 
455
 
 
456
   @todo
 
457
   - TODO is it needed to set this variable if we have no socket
 
458
*/
 
459
 
 
460
/*
 
461
  TODO: rewrite this in a manner to do non-block writes. If a write can not be made, and we are
 
462
  in the server, yield to another process and come back later.
 
463
*/
 
464
static int
 
465
drizzleclient_net_real_write(NET *net, const unsigned char *packet, size_t len)
 
466
{
 
467
  size_t length;
 
468
  const unsigned char *pos, *end;
 
469
  uint32_t retry_count= 0;
 
470
 
 
471
  /* Backup of the original SO_RCVTIMEO timeout */
 
472
 
 
473
  if (net->error == 2)
 
474
    return(-1);                /* socket can't be used */
 
475
 
 
476
  net->reading_or_writing=2;
 
477
  if (net->compress)
 
478
  {
 
479
    size_t complen;
 
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)))
 
484
    {
 
485
      net->error= 2;
 
486
      net->last_errno= CR_OUT_OF_MEMORY;
 
487
      /* In the server, the error is reported by MY_WME flag. */
 
488
      net->reading_or_writing= 0;
 
489
      return(1);
 
490
    }
 
491
    memcpy(b+header_length,packet,len);
 
492
 
 
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
    {
 
516
      complen=0;
 
517
    }
 
518
    int3store(&b[NET_HEADER_SIZE],complen);
 
519
    int3store(b,len);
 
520
    b[3]=(unsigned char) (net->compress_pkt_nr++);
 
521
    len+= header_length;
 
522
    packet= b;
 
523
  }
 
524
 
 
525
  pos= packet;
 
526
  end=pos+len;
 
527
  /* Loop until we have read everything */
 
528
  while (pos != end)
 
529
  {
 
530
    assert(pos);
 
531
    if ((long) (length= drizzleclient_vio_write(net->vio, pos, (size_t) (end-pos))) <= 0)
 
532
    {
 
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
 
545
        on the socket kicks in.
 
546
      */
 
547
      if ((interrupted || length == 0))
 
548
      {
 
549
        bool old_mode;
 
550
 
 
551
        while (drizzleclient_vio_blocking(net->vio, true, &old_mode) < 0)
 
552
        {
 
553
          if (drizzleclient_vio_should_retry(net->vio) && retry_count++ < net->retry_count)
 
554
            continue;
 
555
          net->error= 2;                     /* Close socket */
 
556
          net->last_errno= CR_NET_PACKET_TOO_LARGE;
 
557
          goto end;
 
558
        }
 
559
        retry_count=0;
 
560
        continue;
 
561
      }
 
562
      else
 
563
      {
 
564
        if (retry_count++ < net->retry_count)
 
565
          continue;
 
566
      }
 
567
 
 
568
      if (drizzleclient_vio_errno(net->vio) == EINTR)
 
569
      {
 
570
        continue;
 
571
      }
 
572
      net->error= 2;                /* Close socket */
 
573
      net->last_errno= (interrupted ? CR_NET_WRITE_INTERRUPTED :
 
574
                        CR_NET_ERROR_ON_WRITE);
 
575
      break;
 
576
    }
 
577
    pos+=length;
 
578
  }
 
579
end:
 
580
  if ((net->compress) && (packet != NULL))
 
581
    free((char*) packet);
 
582
  net->reading_or_writing=0;
 
583
 
 
584
  return(((int) (pos != end)));
 
585
}
 
586
 
 
587
 
 
588
/**
 
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.
 
592
 
 
593
   @return
 
594
   Returns length of packet.
 
595
*/
 
596
 
 
597
static uint32_t
 
598
my_real_read(NET *net, size_t *complen)
 
599
{
 
600
  unsigned char *pos;
 
601
  size_t length;
 
602
  uint32_t i,retry_count=0;
 
603
  size_t len=packet_error;
 
604
  uint32_t remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE :
 
605
                    NET_HEADER_SIZE);
 
606
 
 
607
  *complen = 0;
 
608
 
 
609
  net->reading_or_writing= 1;
 
610
  /* Read timeout is set in drizzleclient_net_set_read_timeout */
 
611
 
 
612
  pos = net->buff + net->where_b;        /* net->packet -4 */
 
613
 
 
614
  for (i= 0; i < 2 ; i++)
 
615
  {
 
616
    while (remain > 0)
 
617
    {
 
618
      /* First read is done with non blocking mode */
 
619
      if ((long) (length= drizzleclient_vio_read(net->vio, pos, remain)) <= 0L)
 
620
      {
 
621
        if (net->vio == NULL)
 
622
          goto end;
 
623
 
 
624
        const bool interrupted = drizzleclient_vio_should_retry(net->vio);
 
625
 
 
626
        if (interrupted)
 
627
        {                    /* Probably in MIT threads */
 
628
          if (retry_count++ < net->retry_count)
 
629
            continue;
 
630
        }
 
631
        if (drizzleclient_vio_errno(net->vio) == EINTR)
 
632
        {
 
633
          continue;
 
634
        }
 
635
        len= packet_error;
 
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);
 
641
        goto end;
 
642
      }
 
643
      remain -= (uint32_t) length;
 
644
      pos+= length;
 
645
    }
 
646
    if (i == 0)
 
647
    {                    /* First parts is packet length */
 
648
      uint32_t helping;
 
649
 
 
650
      if (net->buff[net->where_b + 3] != (unsigned char) net->pkt_nr)
 
651
      {
 
652
        len= packet_error;
 
653
        /* Not a NET error on the client. XXX: why? */
 
654
        goto end;
 
655
      }
 
656
      net->compress_pkt_nr= ++net->pkt_nr;
 
657
      if (net->compress)
 
658
      {
 
659
        /*
 
660
          If the packet is compressed then complen > 0 and contains the
 
661
          number of bytes in the uncompressed packet
 
662
        */
 
663
        *complen=uint3korr(&(net->buff[net->where_b + NET_HEADER_SIZE]));
 
664
      }
 
665
 
 
666
      len=uint3korr(net->buff+net->where_b);
 
667
      if (!len)                /* End of big multi-packet */
 
668
        goto end;
 
669
      helping = max(len,*complen) + net->where_b;
 
670
      /* The necessary size of net->buff */
 
671
      if (helping >= net->max_packet)
 
672
      {
 
673
        if (drizzleclient_net_realloc(net,helping))
 
674
        {
 
675
          len= packet_error;          /* Return error and close connection */
 
676
          goto end;
 
677
        }
 
678
      }
 
679
      pos=net->buff + net->where_b;
 
680
      remain = (uint32_t) len;
 
681
    }
 
682
  }
 
683
 
 
684
end:
 
685
  net->reading_or_writing= 0;
 
686
 
 
687
  return(len);
 
688
}
 
689
 
 
690
 
 
691
/**
 
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.
 
705
*/
 
706
 
 
707
uint32_t
 
708
drizzleclient_net_read(NET *net)
 
709
{
 
710
  size_t len, complen;
 
711
 
 
712
  if (!net->compress)
 
713
  {
 
714
    len = my_real_read(net,&complen);
 
715
    if (len == MAX_PACKET_LENGTH)
 
716
    {
 
717
      /* First packet of a multi-packet.  Concatenate the packets */
 
718
      uint32_t save_pos = net->where_b;
 
719
      size_t total_length= 0;
 
720
      do
 
721
      {
 
722
        net->where_b += len;
 
723
        total_length += len;
 
724
        len = my_real_read(net,&complen);
 
725
      } while (len == MAX_PACKET_LENGTH);
 
726
      if (len != packet_error)
 
727
        len+= total_length;
 
728
      net->where_b = save_pos;
 
729
    }
 
730
    net->read_pos = net->buff + net->where_b;
 
731
    if (len != packet_error)
 
732
      net->read_pos[len]=0;        /* Safeguard for drizzleclient_use_result */
 
733
    return len;
 
734
  }
 
735
  else
 
736
  {
 
737
    /* We are using the compressed protocol */
 
738
 
 
739
    uint32_t buf_length;
 
740
    uint32_t start_of_packet;
 
741
    uint32_t first_packet_offset;
 
742
    uint32_t read_length, multi_byte_packet=0;
 
743
 
 
744
    if (net->remain_in_buf)
 
745
    {
 
746
      buf_length= net->buf_length;        /* Data left in old packet */
 
747
      first_packet_offset= start_of_packet= (net->buf_length -
 
748
                                             net->remain_in_buf);
 
749
      /* Restore the character that was overwritten by the end 0 */
 
750
      net->buff[start_of_packet]= net->save_char;
 
751
    }
 
752
    else
 
753
    {
 
754
      /* reuse buffer, as there is nothing in it that we need */
 
755
      buf_length= start_of_packet= first_packet_offset= 0;
 
756
    }
 
757
    for (;;)
 
758
    {
 
759
      uint32_t packet_len;
 
760
 
 
761
      if (buf_length - start_of_packet >= NET_HEADER_SIZE)
 
762
      {
 
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;
 
784
 
 
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
        }
 
802
      }
 
803
      /* Move data down to read next data packet after current one */
 
804
      if (first_packet_offset)
 
805
      {
 
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;
 
811
      }
 
812
 
 
813
      net->where_b=buf_length;
 
814
      if ((packet_len = my_real_read(net,&complen)) == packet_error)
 
815
        return packet_error;
 
816
 
 
817
      if (complen)
 
818
      {
 
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
        }
 
839
      }
 
840
      else
 
841
        complen= packet_len;
 
842
 
 
843
    }
 
844
    buf_length+= complen;
 
845
 
 
846
    net->read_pos=      net->buff+ first_packet_offset + NET_HEADER_SIZE;
 
847
    net->buf_length=    buf_length;
 
848
    net->remain_in_buf= (uint32_t) (buf_length - start_of_packet);
 
849
    len = ((uint32_t) (start_of_packet - first_packet_offset) - NET_HEADER_SIZE -
 
850
           multi_byte_packet);
 
851
    net->save_char= net->read_pos[len];    /* Must be saved */
 
852
    net->read_pos[len]=0;        /* Safeguard for drizzleclient_use_result */
 
853
  }
 
854
  return len;
 
855
  }
 
856
 
 
857
 
 
858
void drizzleclient_net_set_read_timeout(NET *net, uint32_t timeout)
 
859
{
 
860
  net->read_timeout= timeout;
 
861
#ifndef __sun
 
862
  if (net->vio)
 
863
    drizzleclient_vio_timeout(net->vio, 0, timeout);
 
864
#endif
 
865
  return;
 
866
}
 
867
 
 
868
 
 
869
void drizzleclient_net_set_write_timeout(NET *net, uint32_t timeout)
 
870
{
 
871
  net->write_timeout= timeout;
 
872
#ifndef __sun
 
873
  if (net->vio)
 
874
    drizzleclient_vio_timeout(net->vio, 1, timeout);
 
875
#endif
 
876
  return;
 
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