← Back to branch summary

~yshurik/libmemcached/libmemcached-win

« back to all changes in this revision

Viewing changes to libmemcached/connect.cc

  • Committer: Continuous Integration
  • Date: 2013-04-03 13:16:24 UTC
  • mfrom: (1100.1.1 libmemcached-1.2)
  • Revision ID: ci@tangent.org-20130403131624-j59dhv5z5l0lsdld
Merge lp:~tangent-org/libmemcached/1.2-build/ Build: jenkins-Libmemcached-250

Show diffs side-by-side

added added

removed removed

Lines of Context:
libmemcached/connect.cc
64
64
# define TCP_KEEPIDLE 0
65
65
#endif
66
66
 
67
 
static memcached_return_t connect_poll(org::libmemcached::Instance* server, const int connection_error)
 
67
static memcached_return_t connect_poll(memcached_instance_st* server, const int connection_error)
68
68
{
69
69
  struct pollfd fds[1];
70
70
  fds[0].fd= server->fd;
87
87
      int local_errno= get_socket_errno(); // We cache in case closesocket() modifies errno
88
88
      switch (local_errno)
89
89
      {
90
 
#ifdef TARGET_OS_LINUX
 
90
#ifdef __linux__
91
91
      case ERESTART:
92
92
#endif
93
93
      case EINTR:
103
103
 
104
104
      default: // This should not happen
105
105
        break;
106
 
#if 0
107
 
        if (fds[0].revents & POLLERR)
108
 
        {
109
 
          int err;
110
 
          socklen_t len= sizeof(err);
111
 
          if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == 0)
112
 
          {
113
 
            if (err == 0)
114
 
            {
115
 
              // This should never happen, if it does? Punt.  
116
 
              continue;
117
 
            }
118
 
            local_errno= err;
119
 
          }
120
 
        }
121
 
#endif
122
106
      }
123
107
 
124
108
      assert_msg(server->fd != INVALID_SOCKET, "poll() was passed an invalid file descriptor");
146
130
        }
147
131
      }
148
132
 
149
 
      return  memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT);
 
133
      return  memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("(number_of == 0)"));
150
134
    }
151
135
 
152
 
#if 0
153
 
    server->revents(fds[0].revents);
154
 
#endif
155
 
 
156
136
    assert (number_of == 1);
157
137
 
158
138
    if (fds[0].revents & POLLERR or
201
181
  return memcached_set_errno(*server, connection_error, MEMCACHED_AT, memcached_literal_param("connect_poll() was exhausted"));
202
182
}
203
183
 
204
 
static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
 
184
static memcached_return_t set_hostinfo(memcached_instance_st* server)
205
185
{
206
186
  assert(server->type != MEMCACHED_CONNECTION_UNIX_SOCKET);
207
187
  server->clear_addrinfo();
265
245
  return MEMCACHED_SUCCESS;
266
246
}
267
247
 
268
 
static inline void set_socket_nonblocking(org::libmemcached::Instance* server)
 
248
static inline void set_socket_nonblocking(memcached_instance_st* server)
269
249
{
270
 
#ifdef WIN32
 
250
#if defined(_WIN32)
271
251
  u_long arg= 1;
272
252
  if (ioctlsocket(server->fd, FIONBIO, &arg) == SOCKET_ERROR)
273
253
  {
305
285
#endif
306
286
}
307
287
 
308
 
static bool set_socket_options(org::libmemcached::Instance* server)
 
288
static bool set_socket_options(memcached_instance_st* server)
309
289
{
310
290
  assert_msg(server->fd != INVALID_SOCKET, "invalid socket was passed to set_socket_options()");
311
291
 
372
352
 
373
353
#if defined(_WIN32)
374
354
#else
375
 
#if defined(SO_NOSIGPIPE)
 
355
# if defined(SO_NOSIGPIPE)
376
356
  if (SO_NOSIGPIPE)
377
357
  {
378
358
    int set= 1;
388
368
#endif
389
369
    }
390
370
  }
391
 
#endif // SO_NOSIGPIPE
 
371
# endif // SO_NOSIGPIPE
392
372
#endif // _WIN32
393
373
 
394
374
  if (server->root->flags.no_block)
459
439
  return true;
460
440
}
461
441
 
462
 
static memcached_return_t unix_socket_connect(org::libmemcached::Instance* server)
 
442
static memcached_return_t unix_socket_connect(memcached_instance_st* server)
463
443
{
464
 
#ifndef WIN32
 
444
#ifndef _WIN32
465
445
  WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
466
446
 
467
447
  do {
525
505
#endif
526
506
}
527
507
 
528
 
static memcached_return_t network_connect(org::libmemcached::Instance* server)
 
508
static memcached_return_t network_connect(memcached_instance_st* server)
529
509
{
530
510
  bool timeout_error_occured= false;
531
511
 
663
643
 
664
644
  if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)
665
645
  {
666
 
    return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT);
 
646
    return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT,
 
647
                               memcached_literal_param("if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)"));
667
648
  }
668
649
 
669
650
  return memcached_set_error(*server, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); /* The last error should be from connect() */
676
657
  Based on time/failure count fail the connect without trying. This prevents waiting in a state where
677
658
  we get caught spending cycles just waiting.
678
659
*/
679
 
static memcached_return_t backoff_handling(org::libmemcached::Instance* server, bool& in_timeout)
 
660
static memcached_return_t backoff_handling(memcached_instance_st* server, bool& in_timeout)
680
661
{
681
662
  struct timeval curr_time;
682
663
  bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0);
743
724
  return MEMCACHED_SUCCESS;
744
725
}
745
726
 
746
 
static memcached_return_t _memcached_connect(org::libmemcached::Instance* server, const bool set_last_disconnected)
 
727
static memcached_return_t _memcached_connect(memcached_instance_st* server, const bool set_last_disconnected)
747
728
{
748
729
  assert(server);
749
730
  if (server->fd != INVALID_SOCKET)
830
811
  return rc;
831
812
}
832
813
 
833
 
memcached_return_t memcached_connect(org::libmemcached::Instance* server)
 
814
memcached_return_t memcached_connect(memcached_instance_st* server)
834
815
{
835
816
  return _memcached_connect(server, true);
836
817
}