← 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-12-15 19:32:58 UTC
  • mfrom: (677.1.2 devel)
  • Revision ID: brian@tangent.org-20081215193258-fsvc1sh9h7a9sb1t
Merge from Monty

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 <drizzled/global.h>
 
22
#include "libdrizzle.h"
 
23
#include "libdrizzle_priv.h"
 
24
#include <libdrizzle/errmsg.h>
 
25
#include <libdrizzle/vio.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= NULL;
 
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
    assert(pos);
 
552
    if ((long) (length= vio_write(net->vio, pos, (size_t) (end-pos))) <= 0)
 
553
    {
 
554
      const bool interrupted= vio_should_retry(net->vio);
 
555
      /*
 
556
        If we read 0, or we were interrupted this means that
 
557
        we need to switch to blocking mode and wait until the timeout
 
558
        on the socket kicks in.
 
559
      */
 
560
      if ((interrupted || length == 0))
 
561
      {
 
562
        bool old_mode;
 
563
 
 
564
        while (vio_blocking(net->vio, true, &old_mode) < 0)
 
565
        {
 
566
          if (vio_should_retry(net->vio) && retry_count++ < net->retry_count)
 
567
            continue;
 
568
          net->error= 2;                     /* Close socket */
 
569
          net->last_errno= CR_NET_PACKET_TOO_LARGE;
 
570
          goto end;
 
571
        }
 
572
        retry_count=0;
 
573
        continue;
 
574
      }
 
575
      else
 
576
      {
 
577
        if (retry_count++ < net->retry_count)
 
578
          continue;
 
579
      }
 
580
 
 
581
      if (vio_errno(net->vio) == EINTR)
 
582
      {
 
583
        continue;
 
584
      }
 
585
      net->error= 2;                /* Close socket */
 
586
      net->last_errno= (interrupted ? CR_NET_WRITE_INTERRUPTED :
 
587
                        CR_NET_ERROR_ON_WRITE);
 
588
      break;
 
589
    }
 
590
    pos+=length;
 
591
  }
 
592
end:
 
593
  if ((net->compress) && (packet != NULL))
 
594
    free((char*) packet);
 
595
  net->reading_or_writing=0;
 
596
 
 
597
#ifndef __sun
 
598
  if (net->write_timeout)
 
599
    error= setsockopt(net->vio->sd, SOL_SOCKET, SO_RCVTIMEO,
 
600
                      &backtime, (socklen_t)sizeof(struct timespec));
 
601
#endif
 
602
 
 
603
  return(((int) (pos != end)));
 
604
}
 
605
 
 
606
 
 
607
/**
 
608
   Reads one packet to net->buff + net->where_b.
 
609
   Long packets are handled by my_net_read().
 
610
   This function reallocates the net->buff buffer if necessary.
 
611
 
 
612
   @return
 
613
   Returns length of packet.
 
614
*/
 
615
 
 
616
static uint32_t
 
617
my_real_read(NET *net, size_t *complen)
 
618
{
 
619
  unsigned char *pos;
 
620
  size_t length;
 
621
  uint32_t i,retry_count=0;
 
622
  uint32_t len=packet_error;
 
623
  uint32_t remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE :
 
624
                    NET_HEADER_SIZE);
 
625
 
 
626
#ifndef __sun
 
627
  /* Backup of the original SO_RCVTIMEO timeout */
 
628
  struct timespec backtime;
 
629
  int error= 0;
 
630
#endif
 
631
 
 
632
  *complen = 0;
 
633
 
 
634
  net->reading_or_writing= 1;
 
635
  /* Read timeout is set in my_net_set_read_timeout */
 
636
 
 
637
  pos = net->buff + net->where_b;        /* net->packet -4 */
 
638
 
 
639
 
 
640
#ifndef __sun
 
641
  /* Check for error, currently assert */
 
642
  if (net->read_timeout)
 
643
  {
 
644
    struct timespec waittime;
 
645
    socklen_t length;
 
646
 
 
647
    waittime.tv_sec= net->read_timeout;
 
648
    waittime.tv_nsec= 0;
 
649
 
 
650
    memset(&backtime, 0, sizeof(struct timespec));
 
651
    length= sizeof(struct timespec);
 
652
    error= getsockopt(net->vio->sd, SOL_SOCKET, SO_RCVTIMEO,
 
653
                      &backtime, &length);
 
654
    if (error != 0)
 
655
    {
 
656
      perror("getsockopt");
 
657
      assert(error == 0);
 
658
    }
 
659
    error= setsockopt(net->vio->sd, SOL_SOCKET, SO_RCVTIMEO,
 
660
                      &waittime, (socklen_t)sizeof(struct timespec));
 
661
    assert(error == 0);
 
662
  }
 
663
#endif
 
664
 
 
665
  for (i= 0; i < 2 ; i++)
 
666
  {
 
667
    while (remain > 0)
 
668
    {
 
669
      /* First read is done with non blocking mode */
 
670
      if ((long) (length= vio_read(net->vio, pos, remain)) <= 0L)
 
671
      {
 
672
        const bool interrupted = vio_should_retry(net->vio);
 
673
 
 
674
        if (interrupted)
 
675
        {                    /* Probably in MIT threads */
 
676
          if (retry_count++ < net->retry_count)
 
677
            continue;
 
678
        }
 
679
        if (vio_errno(net->vio) == EINTR)
 
680
        {
 
681
          continue;
 
682
        }
 
683
        len= packet_error;
 
684
        net->error= 2;                /* Close socket */
 
685
        net->last_errno= (vio_was_interrupted(net->vio) ?
 
686
                          CR_NET_READ_INTERRUPTED :
 
687
                          CR_NET_READ_ERROR);
 
688
        ER(net->last_errno);
 
689
        goto end;
 
690
      }
 
691
      remain -= (uint32_t) length;
 
692
      pos+= length;
 
693
    }
 
694
    if (i == 0)
 
695
    {                    /* First parts is packet length */
 
696
      uint32_t helping;
 
697
 
 
698
      if (net->buff[net->where_b + 3] != (unsigned char) net->pkt_nr)
 
699
      {
 
700
        len= packet_error;
 
701
        /* Not a NET error on the client. XXX: why? */
 
702
        goto end;
 
703
      }
 
704
      net->compress_pkt_nr= ++net->pkt_nr;
 
705
      if (net->compress)
 
706
      {
 
707
        /*
 
708
          If the packet is compressed then complen > 0 and contains the
 
709
          number of bytes in the uncompressed packet
 
710
        */
 
711
        *complen=uint3korr(&(net->buff[net->where_b + NET_HEADER_SIZE]));
 
712
      }
 
713
 
 
714
      len=uint3korr(net->buff+net->where_b);
 
715
      if (!len)                /* End of big multi-packet */
 
716
        goto end;
 
717
      helping = max(len,*complen) + net->where_b;
 
718
      /* The necessary size of net->buff */
 
719
      if (helping >= net->max_packet)
 
720
      {
 
721
        if (net_realloc(net,helping))
 
722
        {
 
723
          len= packet_error;          /* Return error and close connection */
 
724
          goto end;
 
725
        }
 
726
      }
 
727
      pos=net->buff + net->where_b;
 
728
      remain = (uint32_t) len;
 
729
    }
 
730
  }
 
731
 
 
732
end:
 
733
#ifndef __sun
 
734
  if  (net->read_timeout)
 
735
    error= setsockopt(net->vio->sd, SOL_SOCKET, SO_RCVTIMEO,
 
736
                      &backtime, (socklen_t)sizeof(struct timespec));
 
737
  assert(error == 0);
 
738
#endif
 
739
  net->reading_or_writing= 0;
 
740
 
 
741
  return(len);
 
742
}
 
743
 
 
744
 
 
745
/**
 
746
   Read a packet from the client/server and return it without the internal
 
747
   package header.
 
748
 
 
749
   If the packet is the first packet of a multi-packet packet
 
750
   (which is indicated by the length of the packet = 0xffffff) then
 
751
   all sub packets are read and concatenated.
 
752
 
 
753
   If the packet was compressed, its uncompressed and the length of the
 
754
   uncompressed packet is returned.
 
755
 
 
756
   @return
 
757
   The function returns the length of the found packet or packet_error.
 
758
   net->read_pos points to the read data.
 
759
*/
 
760
 
 
761
uint32_t
 
762
my_net_read(NET *net)
 
763
{
 
764
  size_t len, complen;
 
765
 
 
766
  if (!net->compress)
 
767
  {
 
768
    len = my_real_read(net,&complen);
 
769
    if (len == MAX_PACKET_LENGTH)
 
770
    {
 
771
      /* First packet of a multi-packet.  Concatenate the packets */
 
772
      uint32_t save_pos = net->where_b;
 
773
      size_t total_length= 0;
 
774
      do
 
775
      {
 
776
        net->where_b += len;
 
777
        total_length += len;
 
778
        len = my_real_read(net,&complen);
 
779
      } while (len == MAX_PACKET_LENGTH);
 
780
      if (len != packet_error)
 
781
        len+= total_length;
 
782
      net->where_b = save_pos;
 
783
    }
 
784
    net->read_pos = net->buff + net->where_b;
 
785
    if (len != packet_error)
 
786
      net->read_pos[len]=0;        /* Safeguard for drizzle_use_result */
 
787
    return len;
 
788
  }
 
789
  else
 
790
  {
 
791
    /* We are using the compressed protocol */
 
792
 
 
793
    uint32_t buf_length;
 
794
    uint32_t start_of_packet;
 
795
    uint32_t first_packet_offset;
 
796
    uint32_t read_length, multi_byte_packet=0;
 
797
 
 
798
    if (net->remain_in_buf)
 
799
    {
 
800
      buf_length= net->buf_length;        /* Data left in old packet */
 
801
      first_packet_offset= start_of_packet= (net->buf_length -
 
802
                                             net->remain_in_buf);
 
803
      /* Restore the character that was overwritten by the end 0 */
 
804
      net->buff[start_of_packet]= net->save_char;
 
805
    }
 
806
    else
 
807
    {
 
808
      /* reuse buffer, as there is nothing in it that we need */
 
809
      buf_length= start_of_packet= first_packet_offset= 0;
 
810
    }
 
811
    for (;;)
 
812
    {
 
813
      uint32_t packet_len;
 
814
 
 
815
      if (buf_length - start_of_packet >= NET_HEADER_SIZE)
 
816
      {
 
817
        read_length = uint3korr(net->buff+start_of_packet);
 
818
        if (!read_length)
 
819
        {
 
820
          /* End of multi-byte packet */
 
821
          start_of_packet += NET_HEADER_SIZE;
 
822
          break;
 
823
        }
 
824
        if (read_length + NET_HEADER_SIZE <= buf_length - start_of_packet)
 
825
        {
 
826
          if (multi_byte_packet)
 
827
          {
 
828
            /* Remove packet header for second packet */
 
829
            memmove(net->buff + first_packet_offset + start_of_packet,
 
830
                    net->buff + first_packet_offset + start_of_packet +
 
831
                    NET_HEADER_SIZE,
 
832
                    buf_length - start_of_packet);
 
833
            start_of_packet += read_length;
 
834
            buf_length -= NET_HEADER_SIZE;
 
835
          }
 
836
          else
 
837
            start_of_packet+= read_length + NET_HEADER_SIZE;
 
838
 
 
839
          if (read_length != MAX_PACKET_LENGTH)    /* last package */
 
840
          {
 
841
            multi_byte_packet= 0;        /* No last zero len packet */
 
842
            break;
 
843
          }
 
844
          multi_byte_packet= NET_HEADER_SIZE;
 
845
          /* Move data down to read next data packet after current one */
 
846
          if (first_packet_offset)
 
847
          {
 
848
            memmove(net->buff,net->buff+first_packet_offset,
 
849
                    buf_length-first_packet_offset);
 
850
            buf_length-=first_packet_offset;
 
851
            start_of_packet -= first_packet_offset;
 
852
            first_packet_offset=0;
 
853
          }
 
854
          continue;
 
855
        }
 
856
      }
 
857
      /* Move data down to read next data packet after current one */
 
858
      if (first_packet_offset)
 
859
      {
 
860
        memmove(net->buff,net->buff+first_packet_offset,
 
861
                buf_length-first_packet_offset);
 
862
        buf_length-=first_packet_offset;
 
863
        start_of_packet -= first_packet_offset;
 
864
        first_packet_offset=0;
 
865
      }
 
866
 
 
867
      net->where_b=buf_length;
 
868
      if ((packet_len = my_real_read(net,&complen)) == packet_error)
 
869
        return packet_error;
 
870
 
 
871
      if (complen)
 
872
      {
 
873
        unsigned char * compbuf= (unsigned char *) malloc(complen);
 
874
        if (compbuf != NULL)
 
875
        {
 
876
          uLongf tmp_complen= complen;
 
877
          int error= uncompress((Bytef*) compbuf, &tmp_complen,
 
878
                                (Bytef*) (net->buff + net->where_b),
 
879
                                (uLong)packet_len);
 
880
          complen= tmp_complen;
 
881
 
 
882
          if (error != Z_OK)
 
883
          {
 
884
            net->error= 2;            /* caller will close socket */
 
885
            net->last_errno= CR_NET_UNCOMPRESS_ERROR;
 
886
          }
 
887
          else
 
888
          {
 
889
            memcpy((net->buff + net->where_b), compbuf, complen);
 
890
          }
 
891
          free(compbuf);
 
892
        }
 
893
      }
 
894
      else
 
895
        complen= packet_len;
 
896
 
 
897
    }
 
898
    buf_length+= complen;
 
899
 
 
900
    net->read_pos=      net->buff+ first_packet_offset + NET_HEADER_SIZE;
 
901
    net->buf_length=    buf_length;
 
902
    net->remain_in_buf= (uint32_t) (buf_length - start_of_packet);
 
903
    len = ((uint32_t) (start_of_packet - first_packet_offset) - NET_HEADER_SIZE -
 
904
           multi_byte_packet);
 
905
    net->save_char= net->read_pos[len];    /* Must be saved */
 
906
    net->read_pos[len]=0;        /* Safeguard for drizzle_use_result */
 
907
  }
 
908
  return len;
 
909
  }
 
910
 
 
911
 
 
912
void my_net_set_read_timeout(NET *net, uint32_t timeout)
 
913
{
 
914
  net->read_timeout= timeout;
 
915
#ifndef __sun
 
916
  if (net->vio)
 
917
    vio_timeout(net->vio, 0, timeout);
 
918
#endif
 
919
  return;
 
920
}
 
921
 
 
922
 
 
923
void my_net_set_write_timeout(NET *net, uint32_t timeout)
 
924
{
 
925
  net->write_timeout= timeout;
 
926
#ifndef __sun
 
927
  if (net->vio)
 
928
    vio_timeout(net->vio, 1, timeout);
 
929
#endif
 
930
  return;
 
931
}
 
932
/**
 
933
  Clear possible error state of struct NET
 
934
 
 
935
  @param net  clear the state of the argument
 
936
*/
 
937
 
 
938
void net_clear_error(NET *net)
 
939
{
 
940
  net->last_errno= 0;
 
941
  net->last_error[0]= '\0';
 
942
  strcpy(net->sqlstate, sqlstate_get_not_error());
 
943
}
 
944