← Back to branch summary

~trond-norbye/libmemcached/fragment-read-write

« back to all changes in this revision

Viewing changes to libmemcached/connect.cc

  • Committer: Brian Aker
  • Date: 2011-05-24 20:43:14 UTC
  • mfrom: (929.1.110 libmemcached-build)
  • Revision ID: brian@tangent.org-20110524204314-9ag1kkk4c1a6b3z3
Merge in local trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
libmemcached/connect.cc
37
37
 
38
38
 
39
39
#include <libmemcached/common.h>
40
 
#include <assert.h>
 
40
#include <cassert>
 
41
#include <ctime>
41
42
#include <sys/time.h>
42
 
#include <time.h>
43
43
 
44
44
static memcached_return_t connect_poll(memcached_server_st *ptr)
45
45
{
145
145
    hints.ai_protocol= IPPROTO_TCP;
146
146
  }
147
147
 
148
 
  uint32_t counter= 5;
149
 
  while (--counter)
 
148
  int errcode;
 
149
  switch(errcode= getaddrinfo(server->hostname, str_port, &hints, &server->address_info))
150
150
  {
151
 
    int e= getaddrinfo(server->hostname, str_port, &hints, &server->address_info);
152
 
 
153
 
    if (e == 0)
154
 
    {
155
 
      break;
156
 
    }
157
 
    else if (e == EAI_AGAIN)
158
 
    {
159
 
#ifndef WIN32
160
 
      struct timespec dream, rem;
161
 
 
162
 
      dream.tv_nsec= 1000;
163
 
      dream.tv_sec= 0;
164
 
 
165
 
      nanosleep(&dream, &rem);
166
 
#endif
167
 
      continue;
168
 
    }
169
 
    else
 
151
  case 0:
 
152
    break;
 
153
 
 
154
  case EAI_AGAIN:
 
155
    return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
 
156
 
 
157
  case EAI_SYSTEM:
 
158
      return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_SYSTEM)"));
 
159
 
 
160
  case EAI_BADFLAGS:
 
161
    return memcached_set_error(*server, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_BADFLAGS)"));
 
162
 
 
163
  case EAI_MEMORY:
 
164
    return memcached_set_error(*server, MEMCACHED_ERRNO, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_MEMORY)"));
 
165
 
 
166
  default:
170
167
    {
171
168
      WATCHPOINT_STRING(server->hostname);
172
169
      WATCHPOINT_STRING(gai_strerror(e));
173
 
      return MEMCACHED_HOST_LOOKUP_FAILURE;
 
170
      return memcached_set_error(*server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
174
171
    }
175
172
  }
176
 
 
177
173
  server->address_info_next= server->address_info;
178
174
 
179
175
  return MEMCACHED_SUCCESS;
185
181
  u_long arg = 1;
186
182
  if (ioctlsocket(ptr->fd, FIONBIO, &arg) == SOCKET_ERROR)
187
183
  {
188
 
    ptr->cached_errno= get_socket_errno();
189
 
    return MEMCACHED_CONNECTION_FAILURE;
 
184
    return memcached_set_errno(*ptr, get_socket_errno(), NULL);
190
185
  }
191
186
#else
192
187
  int flags;
199
194
 
200
195
  unlikely (flags == -1)
201
196
  {
202
 
    ptr->cached_errno= errno;
203
 
    return MEMCACHED_CONNECTION_FAILURE;
 
197
    return memcached_set_errno(*ptr, errno, NULL);
204
198
  }
205
199
  else if ((flags & O_NONBLOCK) == 0)
206
200
  {
214
208
 
215
209
    unlikely (rval == -1)
216
210
    {
217
 
      ptr->cached_errno= errno;
218
 
      return MEMCACHED_CONNECTION_FAILURE;
 
211
      return memcached_set_errno(*ptr, errno, NULL);
219
212
    }
220
213
  }
221
214
#endif
363
356
 
364
357
  if ((ptr->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
365
358
  {
366
 
    ptr->cached_errno= errno;
367
 
    return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
 
359
    return memcached_set_errno(*ptr, errno, NULL);
368
360
  }
369
361
 
370
362
  struct sockaddr_un servAddr;
393
385
    }
394
386
  }
395
387
 
396
 
  WATCHPOINT_ASSERT(ptr->fd != -1);
 
388
  WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
397
389
 
398
390
  return MEMCACHED_SUCCESS;
399
391
#else
409
401
  WATCHPOINT_ASSERT(ptr->fd == INVALID_SOCKET);
410
402
  WATCHPOINT_ASSERT(ptr->cursor_active == 0);
411
403
 
412
 
  if (! ptr->address_info)
 
404
  if (not ptr->address_info)
413
405
  {
414
 
    memcached_return_t rc= set_hostinfo(ptr);
415
 
    if (rc != MEMCACHED_SUCCESS)
 
406
    memcached_return_t rc;
 
407
    uint32_t counter= 5;
 
408
    while (--counter)
 
409
    {
 
410
      if ((rc= set_hostinfo(ptr)) != MEMCACHED_TIMEOUT)
 
411
        break;
 
412
 
 
413
#ifndef WIN32
 
414
      struct timespec dream, rem;
 
415
 
 
416
      dream.tv_nsec= 1000;
 
417
      dream.tv_sec= 0;
 
418
 
 
419
      nanosleep(&dream, &rem);
 
420
#endif
 
421
    }
 
422
 
 
423
    if (memcached_failed(rc))
416
424
      return rc;
417
425
  }
418
426
 
430
438
                         ptr->address_info_next->ai_socktype,
431
439
                         ptr->address_info_next->ai_protocol)) < 0)
432
440
    {
433
 
      ptr->cached_errno= get_socket_errno();
434
 
      WATCHPOINT_ERRNO(get_socket_errno());
435
 
      return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
 
441
      return memcached_set_errno(*ptr, get_socket_errno(), NULL);
436
442
    }
437
443
 
438
444
    (void)set_socket_options(ptr);
571
577
    if (ptr->fd != INVALID_SOCKET && ptr->root->sasl.callbacks)
572
578
    {
573
579
      rc= memcached_sasl_authenticate_connection(ptr);
574
 
      if (rc != MEMCACHED_SUCCESS)
 
580
      if (memcached_failed(rc))
575
581
      {
576
582
        (void)closesocket(ptr->fd);
577
583
        ptr->fd= INVALID_SOCKET;