← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzleclient/net_serv.c

  • Committer: Brian Aker
  • Date: 2009-02-08 12:39:10 UTC
  • mfrom: (840.1.21 devel)
  • Revision ID: brian@tangent.org-20090208123910-gaodow8xvkw9ed4l
Merging Monty's work

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzleclient/net_serv.c
50
50
 
51
51
/** Init with packet info. */
52
52
 
53
 
bool my_net_init(NET *net, Vio* vio)
 
53
bool drizzleclient_net_init(NET *net, Vio* vio)
54
54
{
55
55
  net->vio = vio;
56
 
  my_net_local_init(net);            /* Set some limits */
 
56
  drizzleclient_net_local_init(net);            /* Set some limits */
57
57
  if (!(net->buff=(unsigned char*) malloc((size_t) net->max_packet+
58
58
                                          NET_HEADER_SIZE + COMP_HEADER_SIZE)))
59
59
    return(1);
69
69
 
70
70
  if (vio != 0)                    /* If real connection */
71
71
  {
72
 
    net->fd  = vio_fd(vio);            /* For perl DBI/DBD */
73
 
    vio_fastsend(vio);
 
72
    net->fd  = drizzleclient_vio_fd(vio);            /* For perl DBI/DBD */
 
73
    drizzleclient_vio_fastsend(vio);
74
74
  }
75
75
  return(0);
76
76
}
77
77
 
78
 
bool net_init_sock(NET * net, int sock, int flags)
 
78
bool drizzleclient_net_init_sock(NET * net, int sock, int flags)
79
79
{
80
80
 
81
 
  Vio *vio_tmp= vio_new(sock, VIO_TYPE_TCPIP, flags);
82
 
  if (vio_tmp == NULL)
 
81
  Vio *drizzleclient_vio_tmp= drizzleclient_vio_new(sock, VIO_TYPE_TCPIP, flags);
 
82
  if (drizzleclient_vio_tmp == NULL)
83
83
    return true;
84
84
  else
85
 
    if (my_net_init(net, vio_tmp))
 
85
    if (drizzleclient_net_init(net, drizzleclient_vio_tmp))
86
86
    {
87
87
      /* Only delete the temporary vio if we didn't already attach it to the
88
88
       * NET object.
89
89
       */
90
 
      if (vio_tmp && (net->vio != vio_tmp))
91
 
        vio_delete(vio_tmp);
 
90
      if (drizzleclient_vio_tmp && (net->vio != drizzleclient_vio_tmp))
 
91
        drizzleclient_vio_delete(drizzleclient_vio_tmp);
92
92
      else
93
93
      {
94
94
        (void) shutdown(sock, SHUT_RDWR);
99
99
  return false;
100
100
}
101
101
 
102
 
void net_end(NET *net)
 
102
void drizzleclient_net_end(NET *net)
103
103
{
104
104
  if (net->buff != NULL)
105
105
    free(net->buff);
107
107
  return;
108
108
}
109
109
 
110
 
void net_close(NET *net)
 
110
void drizzleclient_net_close(NET *net)
111
111
{
112
112
  if (net->vio != NULL)
113
113
  {
114
 
    vio_delete(net->vio);
 
114
    drizzleclient_vio_delete(net->vio);
115
115
    net->vio= 0;
116
116
  }
117
117
}
118
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)
 
119
bool drizzleclient_net_peer_addr(NET *net, char *buf, uint16_t *port, size_t buflen)
 
120
{
 
121
  return drizzleclient_vio_peer_addr(net->vio, buf, port, buflen);
 
122
}
 
123
 
 
124
void drizzleclient_net_keepalive(NET *net, bool flag)
 
125
{
 
126
  drizzleclient_vio_keepalive(net->vio, flag);
 
127
}
 
128
 
 
129
int drizzleclient_net_get_sd(NET *net)
130
130
{
131
131
  return net->vio->sd;
132
132
}
133
133
 
134
 
bool net_should_close(NET *net)
 
134
bool drizzleclient_net_should_close(NET *net)
135
135
{
136
136
  return net->error || (net->vio == 0);
137
137
}
138
138
 
139
 
bool net_more_data(NET *net)
 
139
bool drizzleclient_net_more_data(NET *net)
140
140
{
141
141
  return (net->vio == 0 || net->vio->read_pos < net->vio->read_end);
142
142
}
143
143
 
144
144
/** Realloc the packet buffer. */
145
145
 
146
 
bool net_realloc(NET *net, size_t length)
 
146
bool drizzleclient_net_realloc(NET *net, size_t length)
147
147
{
148
148
  unsigned char *buff;
149
149
  size_t pkt_length;
209
209
   Read from socket until there is nothing more to read. Discard
210
210
   what is read.
211
211
 
212
 
   If there is anything when to read 'net_clear' is called this
 
212
   If there is anything when to read 'drizzleclient_net_clear' is called this
213
213
   normally indicates an error in the protocol.
214
214
 
215
215
   When connection is properly closed (for TCP it means with
220
220
   @param clear_buffer           if <> 0, then clear all data from comm buff
221
221
*/
222
222
 
223
 
void net_clear(NET *net, bool clear_buffer)
 
223
void drizzleclient_net_clear(NET *net, bool clear_buffer)
224
224
{
225
225
  if (clear_buffer)
226
226
  {
227
227
    while (net_data_is_ready(net->vio->sd) > 0)
228
228
    {
229
229
      /* The socket is ready */
230
 
      if (vio_read(net->vio, net->buff,
 
230
      if (drizzleclient_vio_read(net->vio, net->buff,
231
231
                   (size_t) net->max_packet) <= 0)
232
232
      {
233
233
        net->error= 2;
243
243
 
244
244
/** Flush write_buffer if not empty. */
245
245
 
246
 
bool net_flush(NET *net)
 
246
bool drizzleclient_net_flush(NET *net)
247
247
{
248
248
  bool error= 0;
249
249
  if (net->buff != net->write_pos)
250
250
  {
251
 
    error=net_real_write(net, net->buff,
 
251
    error=drizzleclient_net_real_write(net, net->buff,
252
252
                         (size_t) (net->write_pos - net->buff)) ? 1 : 0;
253
253
    net->write_pos=net->buff;
254
254
  }
274
274
*/
275
275
 
276
276
bool
277
 
my_net_write(NET *net,const unsigned char *packet,size_t len)
 
277
drizzleclient_net_write(NET *net,const unsigned char *packet,size_t len)
278
278
{
279
279
  unsigned char buff[NET_HEADER_SIZE];
280
280
  if (unlikely(!net->vio)) /* nowhere to write */
331
331
*/
332
332
 
333
333
bool
334
 
net_write_command(NET *net,unsigned char command,
 
334
drizzleclient_net_write_command(NET *net,unsigned char command,
335
335
                  const unsigned char *header, size_t head_len,
336
336
                  const unsigned char *packet, size_t len)
337
337
{
365
365
  buff[3]= (unsigned char) net->pkt_nr++;
366
366
  return((net_write_buff(net, buff, header_size) ||
367
367
          (head_len && net_write_buff(net, header, head_len)) ||
368
 
          net_write_buff(net, packet, len) || net_flush(net)) ? 1 : 0 );
 
368
          net_write_buff(net, packet, len) || drizzleclient_net_flush(net)) ? 1 : 0 );
369
369
}
370
370
 
371
371
/**
383
383
   @param len        Length of packet
384
384
 
385
385
   @note
386
 
   The cached buffer can be sent as it is with 'net_flush()'.
 
386
   The cached buffer can be sent as it is with 'drizzleclient_net_flush()'.
387
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
 
388
   MAX_PACKET_LENGTH to drizzleclient_net_real_write() if we are using the compressed
389
389
   protocol as we store the length of the compressed packet in 3 bytes.
390
390
 
391
391
   @retval
409
409
    {
410
410
      /* Fill up already used packet and write it */
411
411
      memcpy(net->write_pos,packet,left_length);
412
 
      if (net_real_write(net, net->buff,
 
412
      if (drizzleclient_net_real_write(net, net->buff,
413
413
                         (size_t) (net->write_pos - net->buff) + left_length))
414
414
        return 1;
415
415
      net->write_pos= net->buff;
425
425
      left_length= MAX_PACKET_LENGTH;
426
426
      while (len > left_length)
427
427
      {
428
 
        if (net_real_write(net, packet, left_length))
 
428
        if (drizzleclient_net_real_write(net, packet, left_length))
429
429
          return 1;
430
430
        packet+= left_length;
431
431
        len-= left_length;
432
432
      }
433
433
    }
434
434
    if (len > net->max_packet)
435
 
      return net_real_write(net, packet, len) ? 1 : 0;
 
435
      return drizzleclient_net_real_write(net, packet, len) ? 1 : 0;
436
436
    /* Send out rest of the blocks as full sized blocks */
437
437
  }
438
438
  memcpy(net->write_pos,packet,len);
454
454
  in the server, yield to another process and come back later.
455
455
*/
456
456
int
457
 
net_real_write(NET *net, const unsigned char *packet, size_t len)
 
457
drizzleclient_net_real_write(NET *net, const unsigned char *packet, size_t len)
458
458
{
459
459
  size_t length;
460
460
  const unsigned char *pos, *end;
549
549
  while (pos != end)
550
550
  {
551
551
    assert(pos);
552
 
    if ((long) (length= vio_write(net->vio, pos, (size_t) (end-pos))) <= 0)
 
552
    if ((long) (length= drizzleclient_vio_write(net->vio, pos, (size_t) (end-pos))) <= 0)
553
553
    {
554
 
      const bool interrupted= vio_should_retry(net->vio);
 
554
      const bool interrupted= drizzleclient_vio_should_retry(net->vio);
555
555
      /*
556
556
        If we read 0, or we were interrupted this means that
557
557
        we need to switch to blocking mode and wait until the timeout
561
561
      {
562
562
        bool old_mode;
563
563
 
564
 
        while (vio_blocking(net->vio, true, &old_mode) < 0)
 
564
        while (drizzleclient_vio_blocking(net->vio, true, &old_mode) < 0)
565
565
        {
566
 
          if (vio_should_retry(net->vio) && retry_count++ < net->retry_count)
 
566
          if (drizzleclient_vio_should_retry(net->vio) && retry_count++ < net->retry_count)
567
567
            continue;
568
568
          net->error= 2;                     /* Close socket */
569
569
          net->last_errno= CR_NET_PACKET_TOO_LARGE;
578
578
          continue;
579
579
      }
580
580
 
581
 
      if (vio_errno(net->vio) == EINTR)
 
581
      if (drizzleclient_vio_errno(net->vio) == EINTR)
582
582
      {
583
583
        continue;
584
584
      }
606
606
 
607
607
/**
608
608
   Reads one packet to net->buff + net->where_b.
609
 
   Long packets are handled by my_net_read().
 
609
   Long packets are handled by drizzleclient_net_read().
610
610
   This function reallocates the net->buff buffer if necessary.
611
611
 
612
612
   @return
632
632
  *complen = 0;
633
633
 
634
634
  net->reading_or_writing= 1;
635
 
  /* Read timeout is set in my_net_set_read_timeout */
 
635
  /* Read timeout is set in drizzleclient_net_set_read_timeout */
636
636
 
637
637
  pos = net->buff + net->where_b;        /* net->packet -4 */
638
638
 
667
667
    while (remain > 0)
668
668
    {
669
669
      /* First read is done with non blocking mode */
670
 
      if ((long) (length= vio_read(net->vio, pos, remain)) <= 0L)
 
670
      if ((long) (length= drizzleclient_vio_read(net->vio, pos, remain)) <= 0L)
671
671
      {
672
 
        const bool interrupted = vio_should_retry(net->vio);
 
672
        const bool interrupted = drizzleclient_vio_should_retry(net->vio);
673
673
 
674
674
        if (interrupted)
675
675
        {                    /* Probably in MIT threads */
676
676
          if (retry_count++ < net->retry_count)
677
677
            continue;
678
678
        }
679
 
        if (vio_errno(net->vio) == EINTR)
 
679
        if (drizzleclient_vio_errno(net->vio) == EINTR)
680
680
        {
681
681
          continue;
682
682
        }
683
683
        len= packet_error;
684
684
        net->error= 2;                /* Close socket */
685
 
        net->last_errno= (vio_was_interrupted(net->vio) ?
 
685
        net->last_errno= (drizzleclient_vio_was_interrupted(net->vio) ?
686
686
                          CR_NET_READ_INTERRUPTED :
687
687
                          CR_NET_READ_ERROR);
688
688
        ER(net->last_errno);
718
718
      /* The necessary size of net->buff */
719
719
      if (helping >= net->max_packet)
720
720
      {
721
 
        if (net_realloc(net,helping))
 
721
        if (drizzleclient_net_realloc(net,helping))
722
722
        {
723
723
          len= packet_error;          /* Return error and close connection */
724
724
          goto end;
759
759
*/
760
760
 
761
761
uint32_t
762
 
my_net_read(NET *net)
 
762
drizzleclient_net_read(NET *net)
763
763
{
764
764
  size_t len, complen;
765
765
 
783
783
    }
784
784
    net->read_pos = net->buff + net->where_b;
785
785
    if (len != packet_error)
786
 
      net->read_pos[len]=0;        /* Safeguard for drizzle_use_result */
 
786
      net->read_pos[len]=0;        /* Safeguard for drizzleclient_use_result */
787
787
    return len;
788
788
  }
789
789
  else
903
903
    len = ((uint32_t) (start_of_packet - first_packet_offset) - NET_HEADER_SIZE -
904
904
           multi_byte_packet);
905
905
    net->save_char= net->read_pos[len];    /* Must be saved */
906
 
    net->read_pos[len]=0;        /* Safeguard for drizzle_use_result */
 
906
    net->read_pos[len]=0;        /* Safeguard for drizzleclient_use_result */
907
907
  }
908
908
  return len;
909
909
  }
910
910
 
911
911
 
912
 
void my_net_set_read_timeout(NET *net, uint32_t timeout)
 
912
void drizzleclient_net_set_read_timeout(NET *net, uint32_t timeout)
913
913
{
914
914
  net->read_timeout= timeout;
915
915
#ifndef __sun
916
916
  if (net->vio)
917
 
    vio_timeout(net->vio, 0, timeout);
 
917
    drizzleclient_vio_timeout(net->vio, 0, timeout);
918
918
#endif
919
919
  return;
920
920
}
921
921
 
922
922
 
923
 
void my_net_set_write_timeout(NET *net, uint32_t timeout)
 
923
void drizzleclient_net_set_write_timeout(NET *net, uint32_t timeout)
924
924
{
925
925
  net->write_timeout= timeout;
926
926
#ifndef __sun
927
927
  if (net->vio)
928
 
    vio_timeout(net->vio, 1, timeout);
 
928
    drizzleclient_vio_timeout(net->vio, 1, timeout);
929
929
#endif
930
930
  return;
931
931
}
935
935
  @param net  clear the state of the argument
936
936
*/
937
937
 
938
 
void net_clear_error(NET *net)
 
938
void drizzleclient_drizzleclient_net_clear_error(NET *net)
939
939
{
940
940
  net->last_errno= 0;
941
941
  net->last_error[0]= '\0';
942
 
  strcpy(net->sqlstate, sqlstate_get_not_error());
 
942
  strcpy(net->sqlstate, drizzleclient_sqlstate_get_not_error());
943
943
}
944
944