← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/net_serv.c

Fix merge issues with 1.0 CC fix.

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