← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to vio/viosocket.c

Merged from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
vio/viosocket.c
31
31
size_t vio_read(Vio * vio, uchar* buf, size_t size)
32
32
{
33
33
  size_t r;
34
 
  DBUG_ENTER("vio_read");
35
 
  DBUG_PRINT("enter", ("sd: %d  buf: 0x%lx  size: %u", vio->sd, (long) buf,
36
 
                       (uint) size));
37
34
 
38
35
  /* Ensure nobody uses vio_read_buff and vio_read simultaneously */
39
 
  DBUG_ASSERT(vio->read_end == vio->read_pos);
 
36
  assert(vio->read_end == vio->read_pos);
40
37
  errno=0;                                      /* For linux */
41
38
  r = read(vio->sd, buf, size);
42
 
#ifndef DBUG_OFF
43
 
  if (r == (size_t) -1)
44
 
  {
45
 
    DBUG_PRINT("vio_error", ("Got error %d during read",errno));
46
 
  }
47
 
#endif /* DBUG_OFF */
48
 
  DBUG_PRINT("exit", ("%ld", (long) r));
49
 
  DBUG_RETURN(r);
 
39
  return r;
50
40
}
51
41
 
52
42
 
59
49
{
60
50
  size_t rc;
61
51
#define VIO_UNBUFFERED_READ_MIN_SIZE 2048
62
 
  DBUG_ENTER("vio_read_buff");
63
 
  DBUG_PRINT("enter", ("sd: %d  buf: 0x%lx  size: %u", vio->sd, (long) buf,
64
 
                       (uint) size));
65
52
 
66
53
  if (vio->read_pos < vio->read_end)
67
54
  {
90
77
  }
91
78
  else
92
79
    rc= vio_read(vio, buf, size);
93
 
  DBUG_RETURN(rc);
 
80
 
 
81
  return rc;
94
82
#undef VIO_UNBUFFERED_READ_MIN_SIZE
95
83
}
96
84
 
98
86
size_t vio_write(Vio * vio, const uchar* buf, size_t size)
99
87
{
100
88
  size_t r;
101
 
  DBUG_ENTER("vio_write");
102
 
  DBUG_PRINT("enter", ("sd: %d  buf: 0x%lx  size: %u", vio->sd, (long) buf,
103
 
                       (uint) size));
 
89
 
104
90
  r = write(vio->sd, buf, size);
105
 
#ifndef DBUG_OFF
106
 
  if (r == (size_t) -1)
107
 
  {
108
 
    DBUG_PRINT("vio_error", ("Got error on write: %d",socket_errno));
109
 
  }
110
 
#endif /* DBUG_OFF */
111
 
  DBUG_PRINT("exit", ("%u", (uint) r));
112
 
  DBUG_RETURN(r);
 
91
 
 
92
  return r;
113
93
}
114
94
 
115
95
int vio_blocking(Vio * vio __attribute__((unused)), my_bool set_blocking_mode,
116
96
                 my_bool *old_mode)
117
97
{
118
98
  int r=0;
119
 
  DBUG_ENTER("vio_blocking");
120
99
 
121
100
  *old_mode= test(!(vio->fcntl_mode & O_NONBLOCK));
122
 
  DBUG_PRINT("enter", ("set_blocking_mode: %d  old_mode: %d",
123
 
                       (int) set_blocking_mode, (int) *old_mode));
124
101
 
125
102
#if !defined(NO_FCNTL_NONBLOCK)
126
103
  if (vio->sd >= 0)
135
112
      r= fcntl(vio->sd, F_SETFL, vio->fcntl_mode);
136
113
      if (r == -1)
137
114
      {
138
 
        DBUG_PRINT("info", ("fcntl failed, errno %d", errno));
139
115
        vio->fcntl_mode= old_fcntl;
140
116
      }
141
117
    }
143
119
#else
144
120
  r= set_blocking_mode ? 0 : 1;
145
121
#endif /* !defined(NO_FCNTL_NONBLOCK) */
146
 
  DBUG_PRINT("exit", ("%d", r));
147
 
  DBUG_RETURN(r);
 
122
  return r;
148
123
}
149
124
 
150
125
my_bool
151
126
vio_is_blocking(Vio * vio)
152
127
{
153
128
  my_bool r;
154
 
  DBUG_ENTER("vio_is_blocking");
155
129
  r = !(vio->fcntl_mode & O_NONBLOCK);
156
 
  DBUG_PRINT("exit", ("%d", (int) r));
157
 
  DBUG_RETURN(r);
 
130
 
 
131
  return r;
158
132
}
159
133
 
160
134
 
161
135
int vio_fastsend(Vio * vio __attribute__((unused)))
162
136
{
163
137
  int r=0;
164
 
  DBUG_ENTER("vio_fastsend");
165
138
 
166
139
#if defined(IPTOS_THROUGHPUT)
167
140
  {
180
153
  }
181
154
  if (r)
182
155
  {
183
 
    DBUG_PRINT("warning", ("Couldn't set socket option for fast send"));
184
156
    r= -1;
185
157
  }
186
 
  DBUG_PRINT("exit", ("%d", r));
187
 
  DBUG_RETURN(r);
 
158
 
 
159
  return r;
188
160
}
189
161
 
190
162
int vio_keepalive(Vio* vio, my_bool set_keep_alive)
191
163
{
192
 
  int r=0;
193
 
  uint opt = 0;
194
 
  DBUG_ENTER("vio_keepalive");
195
 
  DBUG_PRINT("enter", ("sd: %d  set_keep_alive: %d", vio->sd, (int)
196
 
                       set_keep_alive));
 
164
  int r= 0;
 
165
  uint opt= 0;
 
166
 
197
167
  if (vio->type != VIO_TYPE_NAMEDPIPE)
198
168
  {
199
169
    if (set_keep_alive)
200
 
      opt = 1;
201
 
    r = setsockopt(vio->sd, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt,
202
 
                   sizeof(opt));
 
170
      opt= 1;
 
171
    r= setsockopt(vio->sd, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt,
 
172
                  sizeof(opt));
203
173
  }
204
 
  DBUG_RETURN(r);
 
174
 
 
175
  return r;
205
176
}
206
177
 
207
178
 
226
197
int vio_close(Vio * vio)
227
198
{
228
199
  int r=0;
229
 
  DBUG_ENTER("vio_close");
230
200
 if (vio->type != VIO_CLOSED)
231
201
  {
232
 
    DBUG_ASSERT(vio->sd >= 0);
 
202
    assert(vio->sd >= 0);
233
203
    if (shutdown(vio->sd, SHUT_RDWR))
234
204
      r= -1;
235
205
    if (closesocket(vio->sd))
236
206
      r= -1;
237
207
  }
238
 
  if (r)
239
 
  {
240
 
    DBUG_PRINT("vio_error", ("close() failed, error: %d",socket_errno));
241
 
    /* FIXME: error handling (not critical for MySQL) */
242
 
  }
243
208
  vio->type= VIO_CLOSED;
244
209
  vio->sd=   -1;
245
 
  DBUG_RETURN(r);
 
210
 
 
211
  return r;
246
212
}
247
213
 
248
214
 
263
229
 
264
230
my_bool vio_peer_addr(Vio *vio, char *buf, uint16 *port, size_t buflen)
265
231
{
266
 
  DBUG_ENTER("vio_peer_addr");
267
 
  DBUG_PRINT("enter", ("sd: %d", vio->sd));
268
 
 
269
232
  if (vio->localhost)
270
233
  {
271
234
    strmov(buf, "127.0.0.1");
279
242
    if (getpeername(vio->sd, (struct sockaddr *) (&vio->remote),
280
243
                    &addrLen) != 0)
281
244
    {
282
 
      DBUG_PRINT("exit", ("getpeername gave error: %d", socket_errno));
283
 
      DBUG_RETURN(1);
 
245
      return true;
284
246
    }
285
247
    vio->addrLen= (int)addrLen;
286
248
 
289
251
                            buf, buflen,
290
252
                            port_buf, NI_MAXSERV, NI_NUMERICHOST|NI_NUMERICSERV)))
291
253
    {
292
 
      DBUG_PRINT("exit", ("getnameinfo gave error: %s", 
293
 
                          gai_strerror(error)));
294
 
      DBUG_RETURN(1);
 
254
      return true;
295
255
    }
296
256
 
297
257
    *port= (uint16)strtol(port_buf, (char **)NULL, 10);
306
266
    if (!memcmp(buf, "::ffff:127.0.0.1", sizeof("::ffff:127.0.0.1")))
307
267
      strmov(buf, "127.0.0.1");
308
268
  }
309
 
  DBUG_PRINT("exit", ("addr: %s", buf));
310
 
  DBUG_RETURN(0);
 
269
 
 
270
  return false;
311
271
}
312
272
 
313
273
 
318
278
#if defined(HAVE_POLL)
319
279
  struct pollfd fds;
320
280
  int res;
321
 
  DBUG_ENTER("vio_poll");
 
281
 
322
282
  fds.fd=vio->sd;
323
283
  fds.events=POLLIN;
324
284
  fds.revents=0;
325
285
  if ((res=poll(&fds,1,(int) timeout*1000)) <= 0)
326
286
  {
327
 
    DBUG_RETURN(res < 0 ? 0 : 1);               /* Don't return 1 on errors */
 
287
    return res < 0 ? false : true;              /* Don't return 1 on errors */
328
288
  }
329
 
  DBUG_RETURN(fds.revents & (POLLIN | POLLERR | POLLHUP) ? 0 : 1);
 
289
  return (fds.revents & (POLLIN | POLLERR | POLLHUP) ? false : true);
330
290
#else
331
291
  return 0;
332
292
#endif
355
315
{
356
316
#if defined(SO_SNDTIMEO) && defined(SO_RCVTIMEO)
357
317
  int r;
358
 
  DBUG_ENTER("vio_timeout");
359
318
 
360
319
  {
361
320
  /* POSIX specifies time as struct timeval. */
368
327
                sizeof(wait_timeout));
369
328
 
370
329
  }
371
 
 
372
 
#ifndef DBUG_OFF
373
 
  if (r != 0)
374
 
    DBUG_PRINT("error", ("setsockopt failed: %d, errno: %d", r, socket_errno));
375
 
#endif
376
 
 
377
 
  DBUG_VOID_RETURN;
378
330
#else
379
331
/*
380
332
  Platforms not suporting setting of socket timeout should either use