← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/net_serv.c

  • Committer: Brian Aker
  • Date: 2008-10-29 13:46:43 UTC
  • Revision ID: brian@tangent.org-20081029134643-z6jcwjvyruhk2vlu
Updates for ignore file.

Show diffs side-by-side

added added

removed removed

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