← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/net_serv.c

  • Committer: Monty Taylor
  • Date: 2008-09-16 04:26:53 UTC
  • mto: This revision was merged to the branch mainline in revision 391.
  • Revision ID: monty@inaugust.com-20080916042653-59fgd0y0lbw6ohna
Oh dear god the changes. The changes. I'd tell you what they are, but I'd just be making stuff up. Suffice it to day it's mostly all around splitting files in libdrizzle into different files and removing interdepends. And whatever else I happened to see... 

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/net_serv.c
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#include <drizzled/global.h>
22
21
#include "libdrizzle.h"
 
22
#include "libdrizzle_priv.h"
23
23
#include <libdrizzle/errmsg.h>
24
24
#include <vio/violite.h>
 
25
#include <assert.h>
 
26
#include <stdio.h>
 
27
#include <stdlib.h>
 
28
#include <string.h>
25
29
#include <signal.h>
26
30
#include <errno.h>
 
31
#include <sys/socket.h>
27
32
#include <sys/poll.h>
28
33
#include <zlib.h>
29
34
 
53
58
{
54
59
  net->vio = vio;
55
60
  my_net_local_init(net);            /* Set some limits */
56
 
  if (!(net->buff=(uchar*) malloc((size_t) net->max_packet+
 
61
  if (!(net->buff=(unsigned char*) malloc((size_t) net->max_packet+
57
62
                                  NET_HEADER_SIZE + COMP_HEADER_SIZE)))
58
63
    return(1);
59
64
  net->buff_end=net->buff+net->max_packet;
144
149
 
145
150
bool net_realloc(NET *net, size_t length)
146
151
{
147
 
  uchar *buff;
 
152
  unsigned char *buff;
148
153
  size_t pkt_length;
149
154
 
150
155
  if (length >= net->max_packet_size)
159
164
    We must allocate some extra bytes for the end 0 and to be able to
160
165
    read big compressed blocks
161
166
  */
162
 
  if (!(buff= (uchar*) realloc((char*) net->buff, pkt_length +
 
167
  if (!(buff= (unsigned char*) realloc((char*) net->buff, pkt_length +
163
168
                               NET_HEADER_SIZE + COMP_HEADER_SIZE)))
164
169
  {
165
170
    /* @todo: 1 and 2 codes are identical. */
247
252
  bool error= 0;
248
253
  if (net->buff != net->write_pos)
249
254
  {
250
 
    error=test(net_real_write(net, net->buff,
251
 
                              (size_t) (net->write_pos - net->buff)));
 
255
    error=net_real_write(net, net->buff,
 
256
                         (size_t) (net->write_pos - net->buff)) ? 1 : 0;
252
257
    net->write_pos=net->buff;
253
258
  }
254
259
  /* Sync packet number if using compression */
273
278
*/
274
279
 
275
280
bool
276
 
my_net_write(NET *net,const uchar *packet,size_t len)
 
281
my_net_write(NET *net,const unsigned char *packet,size_t len)
277
282
{
278
 
  uchar buff[NET_HEADER_SIZE];
 
283
  unsigned char buff[NET_HEADER_SIZE];
279
284
  if (unlikely(!net->vio)) /* nowhere to write */
280
285
    return 0;
281
286
  /*
287
292
  {
288
293
    const uint32_t z_size = MAX_PACKET_LENGTH;
289
294
    int3store(buff, z_size);
290
 
    buff[3]= (uchar) net->pkt_nr++;
 
295
    buff[3]= (unsigned char) net->pkt_nr++;
291
296
    if (net_write_buff(net, buff, NET_HEADER_SIZE) ||
292
297
        net_write_buff(net, packet, z_size))
293
298
      return 1;
296
301
  }
297
302
  /* Write last packet */
298
303
  int3store(buff,len);
299
 
  buff[3]= (uchar) net->pkt_nr++;
 
304
  buff[3]= (unsigned char) net->pkt_nr++;
300
305
  if (net_write_buff(net, buff, NET_HEADER_SIZE))
301
306
    return 1;
302
 
  return test(net_write_buff(net,packet,len));
 
307
  return net_write_buff(net,packet,len) ? 1 : 0;
303
308
}
304
309
 
305
310
/**
330
335
*/
331
336
 
332
337
bool
333
 
net_write_command(NET *net,uchar command,
334
 
                  const uchar *header, size_t head_len,
335
 
                  const uchar *packet, size_t len)
 
338
net_write_command(NET *net,unsigned char command,
 
339
                  const unsigned char *header, size_t head_len,
 
340
                  const unsigned char *packet, size_t len)
336
341
{
337
342
  uint32_t length=len+1+head_len;            /* 1 extra byte for command */
338
 
  uchar buff[NET_HEADER_SIZE+1];
 
343
  unsigned char buff[NET_HEADER_SIZE+1];
339
344
  uint header_size=NET_HEADER_SIZE+1;
340
345
 
341
346
  buff[4]=command;                /* For first packet */
347
352
    do
348
353
    {
349
354
      int3store(buff, MAX_PACKET_LENGTH);
350
 
      buff[3]= (uchar) net->pkt_nr++;
 
355
      buff[3]= (unsigned char) net->pkt_nr++;
351
356
      if (net_write_buff(net, buff, header_size) ||
352
357
          net_write_buff(net, header, head_len) ||
353
358
          net_write_buff(net, packet, len))
361
366
    len=length;                    /* Data left to be written */
362
367
  }
363
368
  int3store(buff,length);
364
 
  buff[3]= (uchar) net->pkt_nr++;
365
 
  return(test(net_write_buff(net, buff, header_size) ||
366
 
              (head_len && net_write_buff(net, header, head_len)) ||
367
 
              net_write_buff(net, packet, len) || net_flush(net)));
 
369
  buff[3]= (unsigned char) net->pkt_nr++;
 
370
  return((net_write_buff(net, buff, header_size) ||
 
371
          (head_len && net_write_buff(net, header, head_len)) ||
 
372
          net_write_buff(net, packet, len) || net_flush(net)) ? 1 : 0 );
368
373
}
369
374
 
370
375
/**
453
458
  in the server, yield to another process and come back later.
454
459
*/
455
460
int
456
 
net_real_write(NET *net,const uchar *packet, size_t len)
 
461
net_real_write(NET *net,const unsigned char *packet, size_t len)
457
462
{
458
463
  size_t length;
459
 
  const uchar *pos,*end;
 
464
  const unsigned char *pos,*end;
460
465
  uint retry_count= 0;
461
466
 
462
467
  /* Backup of the original SO_RCVTIMEO timeout */
470
475
  if (net->compress)
471
476
  {
472
477
    size_t complen;
473
 
    uchar *b;
 
478
    unsigned char *b;
474
479
    const uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
475
 
    if (!(b= (uchar*) malloc(len + NET_HEADER_SIZE +
 
480
    if (!(b= (unsigned char*) malloc(len + NET_HEADER_SIZE +
476
481
                             COMP_HEADER_SIZE)))
477
482
    {
478
483
      net->error= 2;
510
515
    }
511
516
    int3store(&b[NET_HEADER_SIZE],complen);
512
517
    int3store(b,len);
513
 
    b[3]=(uchar) (net->compress_pkt_nr++);
 
518
    b[3]=(unsigned char) (net->compress_pkt_nr++);
514
519
    len+= header_length;
515
520
    packet= b;
516
521
  }
571
576
          continue;
572
577
      }
573
578
 
574
 
      if (vio_errno(net->vio) == SOCKET_EINTR)
 
579
      if (vio_errno(net->vio) == EINTR)
575
580
      {
576
581
        continue;
577
582
      }
608
613
static uint32_t
609
614
my_real_read(NET *net, size_t *complen)
610
615
{
611
 
  uchar *pos;
 
616
  unsigned char *pos;
612
617
  size_t length;
613
618
  uint i,retry_count=0;
614
619
  uint32_t len=packet_error;
663
668
          if (retry_count++ < net->retry_count)
664
669
            continue;
665
670
        }
666
 
        if (vio_errno(net->vio) == SOCKET_EINTR)
 
671
        if (vio_errno(net->vio) == EINTR)
667
672
        {
668
673
          continue;
669
674
        }
683
688
    {                    /* First parts is packet length */
684
689
      uint32_t helping;
685
690
 
686
 
      if (net->buff[net->where_b + 3] != (uchar) net->pkt_nr)
 
691
      if (net->buff[net->where_b + 3] != (unsigned char) net->pkt_nr)
687
692
      {
688
693
        len= packet_error;
689
694
        /* Not a NET error on the client. XXX: why? */
911
916
    vio_timeout(net->vio, 1, timeout);
912
917
  return;
913
918
}
 
919
/**
 
920
  Clear possible error state of struct NET
 
921
 
 
922
  @param net  clear the state of the argument
 
923
*/
 
924
 
 
925
void net_clear_error(NET *net)
 
926
{
 
927
  net->last_errno= 0;
 
928
  net->last_error[0]= '\0';
 
929
  strcpy(net->sqlstate, sqlstate_get_not_error());
 
930
}
 
931