← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/viosocket.c

  • Committer: Monty Taylor
  • Date: 2008-11-16 23:47:43 UTC
  • mto: (584.1.10 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116234743-c38gmv0pa2kdefaj
Broke out cached_item.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/viosocket.c
21
21
*/
22
22
 
23
23
#define DONT_MAP_VIO
24
 
#include "config.h"
25
 
#include "vio.h"
 
24
#include <drizzled/global.h>
 
25
#include <libdrizzle/vio.h>
 
26
#include <sys/socket.h>
26
27
#include <drizzled/util/test.h>
27
 
 
28
 
#include <sys/socket.h>
29
 
#include <fcntl.h>
30
 
 
31
 
#include <sys/types.h>
 
28
#include <string.h>
 
29
 
32
30
#include <netinet/tcp.h>
33
 
#include <netinet/in.h>
34
31
#include <sys/poll.h>
35
 
#include <unistd.h>
36
32
 
37
33
#include <netdb.h>
38
34
 
39
 
#include <cstdio>
40
 
#include <cstring>
41
 
#include <cassert>
42
 
 
43
 
#include <algorithm>
44
 
 
45
 
using namespace std;
46
 
 
47
 
namespace drizzle_protocol
48
 
{
49
 
 
50
 
 
51
 
int drizzleclient_vio_errno(Vio *vio)
52
 
{
53
 
  (void)vio;
 
35
int vio_errno(Vio *vio __attribute__((unused)))
 
36
{
54
37
  return errno;
55
38
}
56
39
 
57
40
 
58
 
size_t drizzleclient_vio_read(Vio * vio, unsigned char* buf, size_t size)
 
41
size_t vio_read(Vio * vio, unsigned char* buf, size_t size)
59
42
{
60
43
  size_t r;
61
44
 
62
 
  /* Ensure nobody uses drizzleclient_vio_read_buff and drizzleclient_vio_read simultaneously */
 
45
  /* Ensure nobody uses vio_read_buff and vio_read simultaneously */
63
46
  assert(vio->read_end == vio->read_pos);
64
47
  r= read(vio->sd, buf, size);
65
48
 
72
55
  reduce number of syscalls.
73
56
*/
74
57
 
75
 
size_t drizzleclient_vio_read_buff(Vio *vio, unsigned char* buf, size_t size)
 
58
size_t vio_read_buff(Vio *vio, unsigned char* buf, size_t size)
76
59
{
77
60
  size_t rc;
78
61
#define VIO_UNBUFFERED_READ_MIN_SIZE 2048
79
62
 
80
63
  if (vio->read_pos < vio->read_end)
81
64
  {
82
 
    rc= min((size_t) (vio->read_end - vio->read_pos), size);
 
65
    rc= cmin((size_t) (vio->read_end - vio->read_pos), size);
83
66
    memcpy(buf, vio->read_pos, rc);
84
67
    vio->read_pos+= rc;
85
68
    /*
86
69
      Do not try to read from the socket now even if rc < size:
87
 
      drizzleclient_vio_read can return -1 due to an error or non-blocking mode, and
 
70
      vio_read can return -1 due to an error or non-blocking mode, and
88
71
      the safest way to handle it is to move to a separate branch.
89
72
    */
90
73
  }
91
74
  else if (size < VIO_UNBUFFERED_READ_MIN_SIZE)
92
75
  {
93
 
    rc= drizzleclient_vio_read(vio, (unsigned char*) vio->read_buffer, VIO_READ_BUFFER_SIZE);
 
76
    rc= vio_read(vio, (unsigned char*) vio->read_buffer, VIO_READ_BUFFER_SIZE);
94
77
    if (rc != 0 && rc != (size_t) -1)
95
78
    {
96
79
      if (rc > size)
103
86
    }
104
87
  }
105
88
  else
106
 
    rc= drizzleclient_vio_read(vio, buf, size);
 
89
    rc= vio_read(vio, buf, size);
107
90
 
108
91
  return rc;
109
92
#undef VIO_UNBUFFERED_READ_MIN_SIZE
110
93
}
111
94
 
112
95
 
113
 
size_t drizzleclient_vio_write(Vio * vio, const unsigned char* buf, size_t size)
 
96
size_t vio_write(Vio * vio, const unsigned char* buf, size_t size)
114
97
{
115
98
  size_t r;
116
99
 
119
102
  return r;
120
103
}
121
104
 
122
 
int drizzleclient_vio_blocking(Vio * vio, bool set_blocking_mode, bool *old_mode)
 
105
int vio_blocking(Vio * vio, bool set_blocking_mode, bool *old_mode)
123
106
{
124
107
  int r=0;
125
108
 
126
 
  *old_mode= drizzled::test(!(vio->fcntl_mode & O_NONBLOCK));
 
109
  *old_mode= test(!(vio->fcntl_mode & O_NONBLOCK));
127
110
 
128
111
  if (vio->sd >= 0)
129
112
  {
146
129
}
147
130
 
148
131
bool
149
 
drizzleclient_vio_is_blocking(Vio * vio)
 
132
vio_is_blocking(Vio * vio)
150
133
{
151
134
  bool r;
152
135
  r = !(vio->fcntl_mode & O_NONBLOCK);
155
138
}
156
139
 
157
140
 
158
 
int drizzleclient_vio_fastsend(Vio * vio)
 
141
int vio_fastsend(Vio * vio __attribute__((unused)))
159
142
{
160
 
  (void)vio;
161
143
  int nodelay = 1;
162
144
  int error;
163
145
 
172
154
  return error;
173
155
}
174
156
 
175
 
int32_t drizzleclient_vio_keepalive(Vio* vio, bool set_keep_alive)
 
157
int32_t vio_keepalive(Vio* vio, bool set_keep_alive)
176
158
{
177
159
  int r= 0;
178
160
  uint32_t opt= 0;
192
174
 
193
175
 
194
176
bool
195
 
drizzleclient_vio_should_retry(Vio * vio)
 
177
vio_should_retry(Vio * vio __attribute__((unused)))
196
178
{
197
 
  (void)vio;
198
179
  int en = errno;
199
180
  return (en == EAGAIN || en == EINTR ||
200
181
          en == EWOULDBLOCK);
202
183
 
203
184
 
204
185
bool
205
 
drizzleclient_vio_was_interrupted(Vio *vio)
 
186
vio_was_interrupted(Vio *vio __attribute__((unused)))
206
187
{
207
 
  (void)vio;
208
188
  int en= errno;
209
189
  return (en == EAGAIN || en == EINTR ||
210
190
          en == EWOULDBLOCK || en == ETIMEDOUT);
211
191
}
212
192
 
213
193
 
214
 
int drizzleclient_vio_close(Vio * vio)
 
194
int vio_close(Vio * vio)
215
195
{
216
196
  int r=0;
217
197
 if (vio->type != VIO_CLOSED)
229
209
}
230
210
 
231
211
 
232
 
const char *drizzleclient_vio_description(Vio * vio)
 
212
const char *vio_description(Vio * vio)
233
213
{
234
214
  return vio->desc;
235
215
}
236
216
 
237
 
enum enum_vio_type drizzleclient_vio_type(Vio* vio)
 
217
enum enum_vio_type vio_type(Vio* vio)
238
218
{
239
219
  return vio->type;
240
220
}
241
221
 
242
 
int drizzleclient_vio_fd(Vio* vio)
 
222
int vio_fd(Vio* vio)
243
223
{
244
224
  return vio->sd;
245
225
}
246
226
 
247
 
bool drizzleclient_vio_peer_addr(Vio *vio, char *buf, uint16_t *port, size_t buflen)
 
227
bool vio_peer_addr(Vio *vio, char *buf, uint16_t *port, size_t buflen)
248
228
{
249
229
  int error;
250
230
  char port_buf[NI_MAXSERV];
257
237
  }
258
238
  vio->addrLen= (int)addrLen;
259
239
 
260
 
  if ((error= getnameinfo((struct sockaddr *)(&vio->remote),
 
240
  if ((error= getnameinfo((struct sockaddr *)(&vio->remote), 
261
241
                          addrLen,
262
242
                          buf, buflen,
263
243
                          port_buf, NI_MAXSERV, NI_NUMERICHOST|NI_NUMERICSERV)))
273
253
 
274
254
/* Return 0 if there is data to be read */
275
255
 
276
 
bool drizzleclient_vio_poll_read(Vio *vio, int32_t timeout)
 
256
bool vio_poll_read(Vio *vio, int32_t timeout)
277
257
{
278
258
  struct pollfd fds;
279
259
  int res;
289
269
}
290
270
 
291
271
 
292
 
bool drizzleclient_vio_peek_read(Vio *vio, uint32_t *bytes)
 
272
bool vio_peek_read(Vio *vio, uint32_t *bytes)
293
273
{
294
274
  char buf[1024];
295
275
  ssize_t res= recv(vio->sd, &buf, sizeof(buf), MSG_PEEK);
300
280
  return false;
301
281
}
302
282
 
303
 
void drizzleclient_vio_timeout(Vio *vio, bool is_sndtimeo, int32_t timeout)
 
283
void vio_timeout(Vio *vio, bool is_sndtimeo, int32_t timeout)
304
284
{
305
285
  int error;
306
286
 
314
294
  error= setsockopt(vio->sd, SOL_SOCKET, is_sndtimeo ? SO_SNDTIMEO : SO_RCVTIMEO,
315
295
                    &wait_timeout,
316
296
                    (socklen_t)sizeof(struct timeval));
317
 
  if (error == -1 && errno != ENOPROTOOPT)
 
297
  if (error != 0)
318
298
  {
319
299
    perror("setsockopt");
320
300
    assert(error == 0);
321
301
  }
322
302
}
323
 
 
324
 
} /* namespace drizzle_protcol */