← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/mysql_protocol/vio.cc

  • Committer: Brian Aker
  • Date: 2010-03-17 19:18:40 UTC
  • mto: This revision was merged to the branch mainline in revision 1354.
  • Revision ID: brian@gaz-20100317191840-9ro7fajqp6lhaqjo
Update, we now have all of the ANSI INFORMATION_SCHEMA listed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/mysql_protocol/vio.cc
20
20
  the file descriptior.
21
21
*/
22
22
 
 
23
#define DONT_MAP_VIO
23
24
#include "config.h"
24
25
#include "vio.h"
25
26
#include <string.h>
26
 
#include <drizzled/util/test.h>
27
 
#include <sys/socket.h>
28
 
#include <string.h>
29
 
#include <sys/types.h>
30
 
#include <netinet/tcp.h>
31
 
#include <netinet/in.h>
32
 
#include <sys/poll.h>
33
 
#include <unistd.h>
34
 
#include <fcntl.h>
35
 
#include <netdb.h>
36
 
#include <algorithm>
 
27
 
37
28
#include <cstdlib>
38
29
#include <cassert>
39
30
#include <cstdio>
40
31
#include <fcntl.h>
41
32
 
42
 
using namespace std;
43
 
 
44
 
static void _vio_delete(Vio* vio)
 
33
/*
 
34
 * Helper to fill most of the Vio* with defaults.
 
35
 */
 
36
 
 
37
static void drizzleclient_vio_init(Vio* vio, enum enum_vio_type type,
 
38
                     int sd, uint32_t flags)
 
39
{
 
40
  memset(vio, 0, sizeof(*vio));
 
41
  vio->type     = type;
 
42
  vio->sd       = sd;
 
43
  if ((flags & VIO_BUFFERED_READ) &&
 
44
      !(vio->read_buffer= (char*)malloc(VIO_READ_BUFFER_SIZE)))
 
45
    flags&= ~VIO_BUFFERED_READ;
 
46
  {
 
47
    vio->viodelete      =drizzleclient_vio_delete;
 
48
    vio->vioerrno       =drizzleclient_vio_errno;
 
49
    vio->read= (flags & VIO_BUFFERED_READ) ? drizzleclient_vio_read_buff : drizzleclient_vio_read;
 
50
    vio->write          =drizzleclient_vio_write;
 
51
    vio->fastsend       =drizzleclient_vio_fastsend;
 
52
    vio->viokeepalive   =drizzleclient_vio_keepalive;
 
53
    vio->should_retry   =drizzleclient_vio_should_retry;
 
54
    vio->was_interrupted=drizzleclient_vio_was_interrupted;
 
55
    vio->vioclose       =drizzleclient_vio_close;
 
56
    vio->peer_addr      =drizzleclient_vio_peer_addr;
 
57
    vio->vioblocking    =drizzleclient_vio_blocking;
 
58
    vio->is_blocking    =drizzleclient_vio_is_blocking;
 
59
    vio->timeout        =drizzleclient_vio_timeout;
 
60
  }
 
61
}
 
62
 
 
63
 
 
64
/* Reset initialized VIO to use with another transport type */
 
65
 
 
66
void drizzleclient_vio_reset(Vio* vio, enum enum_vio_type type,
 
67
               int sd, uint32_t flags)
 
68
{
 
69
  free(vio->read_buffer);
 
70
  drizzleclient_vio_init(vio, type, sd, flags);
 
71
}
 
72
 
 
73
 
 
74
/* Open the socket or TCP/IP connection and read the fnctl() status */
 
75
 
 
76
Vio *drizzleclient_vio_new(int sd, enum enum_vio_type type, uint32_t flags)
 
77
{
 
78
  Vio *vio = (Vio*) malloc(sizeof(Vio));
 
79
 
 
80
  if (vio != NULL)
 
81
  {
 
82
    drizzleclient_vio_init(vio, type, sd, flags);
 
83
    sprintf(vio->desc, "TCP/IP (%d)", vio->sd);
 
84
    /*
 
85
      We call fcntl() to set the flags and then immediately read them back
 
86
      to make sure that we and the system are in agreement on the state of
 
87
      things.
 
88
 
 
89
      An example of why we need to do this is FreeBSD (and apparently some
 
90
      other BSD-derived systems, like Mac OS X), where the system sometimes
 
91
      reports that the socket is set for non-blocking when it really will
 
92
      block.
 
93
    */
 
94
    fcntl(sd, F_SETFL, 0);
 
95
    vio->fcntl_mode= fcntl(sd, F_GETFL);
 
96
  }
 
97
  return vio;
 
98
}
 
99
 
 
100
 
 
101
void drizzleclient_vio_delete(Vio* vio)
45
102
{
46
103
  if (!vio)
47
104
    return; /* It must be safe to delete null pointers. */
48
105
 
49
 
  if (!vio->closed)
 
106
  if (vio->type != VIO_CLOSED)
50
107
    vio->vioclose(vio);
 
108
  free((unsigned char*) vio->read_buffer);
51
109
  free((unsigned char*) vio);
52
110
}
53
111
 
54
 
static int _vio_errno(Vio *vio)
55
 
{
56
 
  (void)vio;
57
 
  return errno;
58
 
}
59
 
 
60
 
static size_t _vio_read(Vio * vio, unsigned char* buf, size_t size)
61
 
{
62
 
  size_t r;
63
 
 
64
 
  /* Ensure nobody uses vio_read_buff and vio_read simultaneously */
65
 
  assert(vio->read_end == vio->read_pos);
66
 
  r= read(vio->sd, buf, size);
67
 
 
68
 
  return r;
69
 
}
70
 
 
71
 
static size_t _vio_write(Vio * vio, const unsigned char* buf, size_t size)
72
 
{
73
 
  size_t r;
74
 
 
75
 
  r = write(vio->sd, buf, size);
76
 
 
77
 
  return r;
78
 
}
79
 
 
80
 
static int _vio_blocking(Vio * vio, bool set_blocking_mode, bool *old_mode)
81
 
{
82
 
  int r=0;
83
 
 
84
 
  *old_mode= drizzled::test(!(vio->fcntl_mode & O_NONBLOCK));
85
 
 
86
 
  if (vio->sd >= 0)
87
 
  {
88
 
    int old_fcntl=vio->fcntl_mode;
89
 
    if (set_blocking_mode)
90
 
      vio->fcntl_mode &= ~O_NONBLOCK; /* clear bit */
91
 
    else
92
 
      vio->fcntl_mode |= O_NONBLOCK; /* set bit */
93
 
    if (old_fcntl != vio->fcntl_mode)
94
 
    {
95
 
      r= fcntl(vio->sd, F_SETFL, vio->fcntl_mode);
96
 
      if (r == -1)
97
 
      {
98
 
        vio->fcntl_mode= old_fcntl;
99
 
      }
100
 
    }
101
 
  }
102
 
 
103
 
  return r;
104
 
}
105
 
 
106
 
static int _vio_fastsend(Vio * vio)
107
 
{
108
 
  (void)vio;
109
 
  int nodelay = 1;
110
 
  int error;
111
 
 
112
 
  error= setsockopt(vio->sd, IPPROTO_TCP, TCP_NODELAY,
113
 
                    &nodelay, sizeof(nodelay));
114
 
  if (error != 0)
115
 
  {
116
 
    perror("setsockopt");
117
 
    assert(error == 0);
118
 
  }
119
 
 
120
 
  return error;
121
 
}
122
 
 
123
 
static int32_t _vio_keepalive(Vio* vio, bool set_keep_alive)
124
 
{
125
 
  int r= 0;
126
 
  uint32_t opt= 0;
127
 
 
128
 
  if (set_keep_alive)
129
 
    opt= 1;
130
 
 
131
 
  r= setsockopt(vio->sd, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt, sizeof(opt));
132
 
  if (r != 0)
133
 
  {
134
 
    perror("setsockopt");
135
 
    assert(r == 0);
136
 
  }
137
 
 
138
 
  return r;
139
 
}
140
 
 
141
 
static bool _vio_should_retry(Vio * vio)
142
 
{
143
 
  (void)vio;
144
 
  int en = errno;
145
 
  return (en == EAGAIN || en == EINTR ||
146
 
          en == EWOULDBLOCK);
147
 
}
148
 
 
149
 
static bool _vio_was_interrupted(Vio *vio)
150
 
{
151
 
  (void)vio;
152
 
  int en= errno;
153
 
  return (en == EAGAIN || en == EINTR ||
154
 
          en == EWOULDBLOCK || en == ETIMEDOUT);
155
 
}
156
 
 
157
 
static int _vio_close(Vio * vio)
158
 
{
159
 
  int r=0;
160
 
 if (!vio->closed)
161
 
  {
162
 
    assert(vio->sd >= 0);
163
 
    if (shutdown(vio->sd, SHUT_RDWR))
164
 
      r= -1;
165
 
    if (close(vio->sd))
166
 
      r= -1;
167
 
  }
168
 
  vio->closed= true;
169
 
  vio->sd=   -1;
170
 
 
171
 
  return r;
172
 
}
173
 
 
174
 
static bool _vio_peer_addr(Vio *vio, char *buf, uint16_t *port, size_t buflen)
175
 
{
176
 
  int error;
177
 
  char port_buf[NI_MAXSERV];
178
 
  socklen_t addrLen = sizeof(vio->remote);
179
 
 
180
 
  if (getpeername(vio->sd, (struct sockaddr *) (&vio->remote),
181
 
                  &addrLen) != 0)
182
 
  {
183
 
    return true;
184
 
  }
185
 
  vio->addrLen= (int)addrLen;
186
 
 
187
 
  if ((error= getnameinfo((struct sockaddr *)(&vio->remote),
188
 
                          addrLen,
189
 
                          buf, buflen,
190
 
                          port_buf, NI_MAXSERV, NI_NUMERICHOST|NI_NUMERICSERV)))
191
 
  {
192
 
    return true;
193
 
  }
194
 
 
195
 
  *port= (uint16_t)strtol(port_buf, (char **)NULL, 10);
196
 
 
197
 
  return false;
198
 
}
199
 
 
200
 
static void _vio_timeout(Vio *vio, bool is_sndtimeo, int32_t timeout)
201
 
{
202
 
  int error;
203
 
 
204
 
  /* POSIX specifies time as struct timeval. */
205
 
  struct timeval wait_timeout;
206
 
  wait_timeout.tv_sec= timeout;
207
 
  wait_timeout.tv_usec= 0;
208
 
 
209
 
  assert(timeout >= 0 && timeout <= INT32_MAX);
210
 
  assert(vio->sd != -1);
211
 
  error= setsockopt(vio->sd, SOL_SOCKET, is_sndtimeo ? SO_SNDTIMEO : SO_RCVTIMEO,
212
 
                    &wait_timeout,
213
 
                    (socklen_t)sizeof(struct timeval));
214
 
  if (error == -1 && errno != ENOPROTOOPT)
215
 
  {
216
 
    perror("setsockopt");
217
 
    assert(error == 0);
218
 
  }
219
 
}
220
 
 
221
 
/* Open the socket or TCP/IP connection and read the fnctl() status */
222
 
Vio *mysql_protocol_vio_new(int sd)
223
 
{
224
 
  Vio *vio = (Vio*) malloc(sizeof(Vio));
225
 
  if (vio == NULL)
226
 
    return NULL;
227
 
 
228
 
  memset(vio, 0, sizeof(*vio));
229
 
  vio->closed= false;
230
 
  vio->sd= sd;
231
 
  vio->viodelete= _vio_delete;
232
 
  vio->vioerrno= _vio_errno;
233
 
  vio->read= _vio_read;
234
 
  vio->write= _vio_write;
235
 
  vio->fastsend= _vio_fastsend;
236
 
  vio->viokeepalive= _vio_keepalive;
237
 
  vio->should_retry= _vio_should_retry;
238
 
  vio->was_interrupted= _vio_was_interrupted;
239
 
  vio->vioclose= _vio_close;
240
 
  vio->peer_addr= _vio_peer_addr;
241
 
  vio->vioblocking= _vio_blocking;
242
 
  vio->timeout= _vio_timeout;
243
 
 
244
 
  /*
245
 
    We call fcntl() to set the flags and then immediately read them back
246
 
    to make sure that we and the system are in agreement on the state of
247
 
    things.
248
 
 
249
 
    An example of why we need to do this is FreeBSD (and apparently some
250
 
    other BSD-derived systems, like Mac OS X), where the system sometimes
251
 
    reports that the socket is set for non-blocking when it really will
252
 
    block.
253
 
  */
254
 
  fcntl(sd, F_SETFL, 0);
255
 
  vio->fcntl_mode= fcntl(sd, F_GETFL);
256
 
 
257
 
  return vio;
 
112
 
 
113
/*
 
114
  Cleanup memory allocated by vio or the
 
115
  components below it when application finish
 
116
 
 
117
*/
 
118
void drizzleclient_vio_end(void)
 
119
{
258
120
}