← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/oldlibdrizzle/net_serv.cc

  • Committer: Brian Aker
  • Date: 2009-07-16 22:37:01 UTC
  • mto: This revision was merged to the branch mainline in revision 1100.
  • Revision ID: brian@gaz-20090716223701-vbbbo8dmgd2ljqqo
Refactor TableShare has to be behind class.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/oldlibdrizzle/net_serv.cc
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#include "config.h"
 
21
#include <drizzled/global.h>
22
22
#include <drizzled/session.h>
23
 
 
 
23
#include "libdrizzle.h"
 
24
#include "libdrizzle_priv.h"
 
25
#include "errmsg.h"
 
26
#include "vio.h"
24
27
#include <assert.h>
25
28
#include <stdio.h>
26
29
#include <stdlib.h>
30
33
#include <sys/socket.h>
31
34
#include <sys/poll.h>
32
35
#include <zlib.h>
 
36
 
33
37
#include <algorithm>
34
38
 
35
 
#include "errmsg.h"
36
 
#include "vio.h"
37
 
#include "net_serv.h"
38
 
 
39
39
using namespace std;
40
40
 
41
 
namespace drizzle_protocol
42
 
{
43
 
 
44
41
/*
45
42
  The following handles the differences when this is linked between the
46
43
  client and the server.
50
47
  can't normally do this the client should have a bigger max_allowed_packet.
51
48
*/
52
49
 
53
 
  /* Constants when using compression */
54
 
#define NET_HEADER_SIZE 4               /* standard header size */
55
 
#define COMP_HEADER_SIZE 3              /* compression header extra size */
56
50
 
57
51
#define MAX_PACKET_LENGTH (256L*256L*256L-1)
58
 
const char  *not_error_sqlstate= "00000";
59
52
 
60
53
static bool net_write_buff(NET *net, const unsigned char *packet, uint32_t len);
61
 
static int drizzleclient_net_real_write(NET *net, const unsigned char *packet, size_t len);
 
54
 
 
55
void drizzleclient_net_local_init(NET *net)
 
56
{
 
57
  net->max_packet= (uint32_t) global_system_variables.net_buffer_length;
 
58
 
 
59
  drizzleclient_net_set_read_timeout(net,
 
60
                          (uint32_t)global_system_variables.net_read_timeout);
 
61
  drizzleclient_net_set_write_timeout(net,
 
62
                         (uint32_t)global_system_variables.net_write_timeout);
 
63
 
 
64
  net->retry_count=  (uint32_t) global_system_variables.net_retry_count;
 
65
  net->max_packet_size= max(global_system_variables.net_buffer_length,
 
66
                             global_system_variables.max_allowed_packet);
 
67
}
62
68
 
63
69
/** Init with packet info. */
64
70
 
65
 
bool drizzleclient_net_init(NET *net, Vio* vio, uint32_t buffer_length)
 
71
bool drizzleclient_net_init(NET *net, Vio* vio)
66
72
{
67
73
  net->vio = vio;
68
 
  net->max_packet= (uint32_t) buffer_length;
69
 
  net->max_packet_size= max(buffer_length,
70
 
                            drizzled::global_system_variables.max_allowed_packet);
71
 
 
 
74
  drizzleclient_net_local_init(net);            /* Set some limits */
72
75
  if (!(net->buff=(unsigned char*) malloc((size_t) net->max_packet+
73
76
                                          NET_HEADER_SIZE + COMP_HEADER_SIZE)))
74
77
    return(1);
90
93
  return(0);
91
94
}
92
95
 
93
 
bool drizzleclient_net_init_sock(NET * net, int sock, int flags,
94
 
                                 uint32_t buffer_length)
 
96
bool drizzleclient_net_init_sock(NET * net, int sock, int flags)
95
97
{
96
98
 
97
99
  Vio *drizzleclient_vio_tmp= drizzleclient_vio_new(sock, VIO_TYPE_TCPIP, flags);
98
100
  if (drizzleclient_vio_tmp == NULL)
99
101
    return true;
100
102
  else
101
 
    if (drizzleclient_net_init(net, drizzleclient_vio_tmp, buffer_length))
 
103
    if (drizzleclient_net_init(net, drizzleclient_vio_tmp))
102
104
    {
103
105
      /* Only delete the temporary vio if we didn't already attach it to the
104
106
       * NET object.
147
149
  return net->vio->sd;
148
150
}
149
151
 
 
152
bool drizzleclient_net_should_close(NET *net)
 
153
{
 
154
  return net->error || (net->vio == 0);
 
155
}
 
156
 
150
157
bool drizzleclient_net_more_data(NET *net)
151
158
{
152
159
  return (net->vio == 0 || net->vio->read_pos < net->vio->read_end);
154
161
 
155
162
/** Realloc the packet buffer. */
156
163
 
157
 
static bool drizzleclient_net_realloc(NET *net, size_t length)
 
164
bool drizzleclient_net_realloc(NET *net, size_t length)
158
165
{
159
166
  unsigned char *buff;
160
167
  size_t pkt_length;
464
471
  TODO: rewrite this in a manner to do non-block writes. If a write can not be made, and we are
465
472
  in the server, yield to another process and come back later.
466
473
*/
467
 
static int
 
474
int
468
475
drizzleclient_net_real_write(NET *net, const unsigned char *packet, size_t len)
469
476
{
470
477
  size_t length;
533
540
    assert(pos);
534
541
    if ((long) (length= drizzleclient_vio_write(net->vio, pos, (size_t) (end-pos))) <= 0)
535
542
    {
536
 
     /*
537
 
      * We could end up here with net->vio == NULL
538
 
      * See LP bug#436685
539
 
      * If that is the case, we exit the while loop
540
 
      */
541
 
      if (net->vio == NULL)
542
 
        break;
543
 
      
544
543
      const bool interrupted= drizzleclient_vio_should_retry(net->vio);
545
544
      /*
546
545
        If we read 0, or we were interrupted this means that
621
620
      /* First read is done with non blocking mode */
622
621
      if ((long) (length= drizzleclient_vio_read(net->vio, pos, remain)) <= 0L)
623
622
      {
624
 
        if (net->vio == NULL)
625
 
          goto end;
626
 
 
627
623
        const bool interrupted = drizzleclient_vio_should_retry(net->vio);
628
624
 
629
625
        if (interrupted)
888
884
{
889
885
  net->last_errno= 0;
890
886
  net->last_error[0]= '\0';
891
 
  strcpy(net->sqlstate, not_error_sqlstate);
 
887
  strcpy(net->sqlstate, drizzleclient_sqlstate_get_not_error());
892
888
}
893
889
 
894
 
} /* namespace drizzle_protocol */