← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to vio/viosocket.c

  • Committer: Brian Aker
  • Date: 2008-08-01 19:01:50 UTC
  • Revision ID: brian@tangent.org-20080801190150-003gpp2343cn7cfz
Removed final trace of crypt() lock.

Show diffs side-by-side

added added

removed removed

Lines of Context:
vio/viosocket.c
21
21
*/
22
22
 
23
23
#include "vio_priv.h"
24
 
#include <sys/socket.h>
25
 
#include <drizzled/util/test.h>
26
24
 
27
25
int vio_errno(Vio *vio __attribute__((unused)))
28
26
{
29
 
  return errno;
 
27
  return socket_errno;          /* On Win32 this mapped to WSAGetLastError() */
30
28
}
31
29
 
32
30
 
33
 
size_t vio_read(Vio * vio, unsigned char* buf, size_t size)
 
31
size_t vio_read(Vio * vio, uchar* buf, size_t size)
34
32
{
35
33
  size_t r;
36
34
 
47
45
  reduce number of syscalls.
48
46
*/
49
47
 
50
 
size_t vio_read_buff(Vio *vio, unsigned char* buf, size_t size)
 
48
size_t vio_read_buff(Vio *vio, uchar* buf, size_t size)
51
49
{
52
50
  size_t rc;
53
51
#define VIO_UNBUFFERED_READ_MIN_SIZE 2048
54
52
 
55
53
  if (vio->read_pos < vio->read_end)
56
54
  {
57
 
    rc= cmin((size_t) (vio->read_end - vio->read_pos), size);
 
55
    rc= min((size_t) (vio->read_end - vio->read_pos), size);
58
56
    memcpy(buf, vio->read_pos, rc);
59
57
    vio->read_pos+= rc;
60
58
    /*
65
63
  }
66
64
  else if (size < VIO_UNBUFFERED_READ_MIN_SIZE)
67
65
  {
68
 
    rc= vio_read(vio, (unsigned char*) vio->read_buffer, VIO_READ_BUFFER_SIZE);
 
66
    rc= vio_read(vio, (uchar*) vio->read_buffer, VIO_READ_BUFFER_SIZE);
69
67
    if (rc != 0 && rc != (size_t) -1)
70
68
    {
71
69
      if (rc > size)
85
83
}
86
84
 
87
85
 
88
 
size_t vio_write(Vio * vio, const unsigned char* buf, size_t size)
 
86
size_t vio_write(Vio * vio, const uchar* buf, size_t size)
89
87
{
90
88
  size_t r;
91
89
 
133
131
int vio_fastsend(Vio * vio __attribute__((unused)))
134
132
{
135
133
  int nodelay = 1;
136
 
  int error;
137
 
 
138
 
  error= setsockopt(vio->sd, IPPROTO_TCP, TCP_NODELAY,
139
 
                    &nodelay, sizeof(nodelay));
140
 
  if (error != 0)
141
 
  {
142
 
    perror("setsockopt");
143
 
    assert(error == 0);
144
 
  }
145
 
 
146
 
  return error;
 
134
  int r;
 
135
 
 
136
  r= setsockopt(vio->sd, IPPROTO_TCP, TCP_NODELAY,
 
137
                &nodelay, sizeof(nodelay));
 
138
  assert(r == 0);
 
139
 
 
140
  return r;
147
141
}
148
142
 
149
143
int32_t vio_keepalive(Vio* vio, bool set_keep_alive)
155
149
    opt= 1;
156
150
 
157
151
  r= setsockopt(vio->sd, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt, sizeof(opt));
158
 
  if (r != 0)
159
 
  {
160
 
    perror("setsockopt");
161
 
    assert(r == 0);
162
 
  }
163
152
 
164
153
  return r;
165
154
}
168
157
bool
169
158
vio_should_retry(Vio * vio __attribute__((unused)))
170
159
{
171
 
  int en = errno;
172
 
  return (en == EAGAIN || en == EINTR ||
173
 
          en == EWOULDBLOCK);
 
160
  int en = socket_errno;
 
161
  return (en == SOCKET_EAGAIN || en == SOCKET_EINTR ||
 
162
          en == SOCKET_EWOULDBLOCK);
174
163
}
175
164
 
176
165
 
177
166
bool
178
167
vio_was_interrupted(Vio *vio __attribute__((unused)))
179
168
{
180
 
  int en= errno;
181
 
  return (en == EAGAIN || en == EINTR ||
182
 
          en == EWOULDBLOCK || en == ETIMEDOUT);
 
169
  int en= socket_errno;
 
170
  return (en == SOCKET_EAGAIN || en == SOCKET_EINTR ||
 
171
          en == SOCKET_EWOULDBLOCK || en == SOCKET_ETIMEDOUT);
183
172
}
184
173
 
185
174
 
191
180
    assert(vio->sd >= 0);
192
181
    if (shutdown(vio->sd, SHUT_RDWR))
193
182
      r= -1;
194
 
    if (close(vio->sd))
 
183
    if (closesocket(vio->sd))
195
184
      r= -1;
196
185
  }
197
186
  vio->type= VIO_CLOSED;
211
200
  return vio->type;
212
201
}
213
202
 
214
 
int vio_fd(Vio* vio)
 
203
my_socket vio_fd(Vio* vio)
215
204
{
216
205
  return vio->sd;
217
206
}
245
234
 
246
235
/* Return 0 if there is data to be read */
247
236
 
248
 
bool vio_poll_read(Vio *vio, int32_t timeout)
 
237
bool vio_poll_read(Vio *vio,uint timeout)
249
238
{
250
239
  struct pollfd fds;
251
240
  int res;
272
261
  return false;
273
262
}
274
263
 
275
 
void vio_timeout(Vio *vio, bool is_sndtimeo, int32_t timeout)
 
264
void vio_timeout(Vio *vio, uint which, uint timeout)
276
265
{
277
 
  int error;
 
266
  int r;
278
267
 
279
268
  /* POSIX specifies time as struct timeval. */
280
269
  struct timeval wait_timeout;
281
270
  wait_timeout.tv_sec= timeout;
282
271
  wait_timeout.tv_usec= 0;
283
272
 
284
 
  assert(timeout >= 0 && timeout <= INT32_MAX);
285
 
  assert(vio->sd != -1);
286
 
  error= setsockopt(vio->sd, SOL_SOCKET, is_sndtimeo ? SO_SNDTIMEO : SO_RCVTIMEO,
287
 
                    &wait_timeout,
288
 
                    (socklen_t)sizeof(struct timeval));
289
 
  if (error != 0)
290
 
  {
291
 
    perror("setsockopt");
292
 
    assert(error == 0);
293
 
  }
 
273
  r= setsockopt(vio->sd, SOL_SOCKET, which ? SO_SNDTIMEO : SO_RCVTIMEO,
 
274
                IF_WIN(const char*, const void*)&wait_timeout,
 
275
                sizeof(wait_timeout));
 
276
  assert(r == 0);
294
277
}