1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2010 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <libmemcached/common.h>
44 # define SOCK_CLOEXEC 0
48 # define SOCK_NONBLOCK 0
56 # define SO_NOSIGPIPE 0
60 # define TCP_NODELAY 0
64 # define TCP_KEEPIDLE 0
67 static memcached_return_t
connect_poll(org::libmemcached::Instance
* server
)
70 fds
[0].fd
= server
->fd
;
71 fds
[0].events
= server
->events();
76 if (server
->root
->poll_timeout
== 0)
78 return memcached_set_error(*server
, MEMCACHED_TIMEOUT
, MEMCACHED_AT
);
81 while (--loop_max
) // Should only loop on cases of ERESTART or EINTR
84 if ((number_of
= poll(fds
, 1, server
->root
->connect_timeout
)) <= 0)
88 int local_errno
= get_socket_errno(); // We cache in case closesocket() modifies errno
91 #ifdef TARGET_OS_LINUX
99 return memcached_set_error(*server
, MEMCACHED_MEMORY_ALLOCATION_FAILURE
, MEMCACHED_AT
);
102 return memcached_set_error(*server
, MEMCACHED_MEMORY_ALLOCATION_FAILURE
, MEMCACHED_AT
, memcached_literal_param("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid"));
104 default: // This should not happen
105 if (fds
[0].revents
& POLLERR
)
108 socklen_t len
= sizeof(err
);
109 if (getsockopt(server
->fd
, SOL_SOCKET
, SO_ERROR
, (char*)&err
, &len
) == 0)
113 // This should never happen, if it does? Punt.
120 assert_msg(server
->fd
!= INVALID_SOCKET
, "poll() was passed an invalid file descriptor");
121 (void)closesocket(server
->fd
);
122 server
->fd
= INVALID_SOCKET
;
123 server
->state
= MEMCACHED_SERVER_STATE_NEW
;
125 return memcached_set_errno(*server
, local_errno
, MEMCACHED_AT
);
128 assert(number_of
== 0);
130 server
->io_wait_count
.timeouts
++;
131 return memcached_set_error(*server
, MEMCACHED_TIMEOUT
, MEMCACHED_AT
);
135 server
->revents(fds
[0].revents
);
138 if (fds
[0].revents
& POLLERR
or
139 fds
[0].revents
& POLLHUP
or
140 fds
[0].revents
& POLLNVAL
)
143 socklen_t len
= sizeof (err
);
144 if (getsockopt(fds
[0].fd
, SOL_SOCKET
, SO_ERROR
, (char*)&err
, &len
) == 0)
146 // We check the value to see what happened wth the socket.
149 return MEMCACHED_SUCCESS
;
154 return memcached_set_errno(*server
, err
, MEMCACHED_AT
);
156 assert(fds
[0].revents
& POLLIN
or fds
[0].revents
& POLLOUT
);
158 return MEMCACHED_SUCCESS
;
161 // This should only be possible from ERESTART or EINTR;
162 return memcached_set_errno(*server
, get_socket_errno(), MEMCACHED_AT
);
165 static memcached_return_t
set_hostinfo(org::libmemcached::Instance
* server
)
167 assert(server
->type
!= MEMCACHED_CONNECTION_UNIX_SOCKET
);
168 if (server
->address_info
)
170 freeaddrinfo(server
->address_info
);
171 server
->address_info
= NULL
;
172 server
->address_info_next
= NULL
;
175 char str_port
[MEMCACHED_NI_MAXSERV
];
176 int length
= snprintf(str_port
, MEMCACHED_NI_MAXSERV
, "%u", uint32_t(server
->port()));
177 if (length
>= MEMCACHED_NI_MAXSERV
or length
<= 0)
179 return memcached_set_error(*server
, MEMCACHED_MEMORY_ALLOCATION_FAILURE
, MEMCACHED_AT
,
180 memcached_literal_param("snprintf(NI_MAXSERV)"));
183 struct addrinfo hints
;
184 memset(&hints
, 0, sizeof(struct addrinfo
));
187 hints
.ai_family
= AF_INET
;
189 if (memcached_is_udp(server
->root
))
191 hints
.ai_protocol
= IPPROTO_UDP
;
192 hints
.ai_socktype
= SOCK_DGRAM
;
196 hints
.ai_socktype
= SOCK_STREAM
;
197 hints
.ai_protocol
= IPPROTO_TCP
;
200 assert(server
->address_info
== NULL
);
201 assert(server
->address_info_next
== NULL
);
203 switch(errcode
= getaddrinfo(server
->hostname
, str_port
, &hints
, &server
->address_info
))
209 return memcached_set_error(*server
, MEMCACHED_TIMEOUT
, MEMCACHED_AT
, memcached_string_make_from_cstr(gai_strerror(errcode
)));
212 if (server
->address_info
)
214 freeaddrinfo(server
->address_info
);
215 server
->address_info
= NULL
;
216 server
->address_info_next
= NULL
;
218 return memcached_set_errno(*server
, errno
, MEMCACHED_AT
, memcached_literal_param("getaddrinfo(EAI_SYSTEM)"));
221 if (server
->address_info
)
223 freeaddrinfo(server
->address_info
);
224 server
->address_info
= NULL
;
225 server
->address_info_next
= NULL
;
227 return memcached_set_error(*server
, MEMCACHED_INVALID_ARGUMENTS
, MEMCACHED_AT
, memcached_literal_param("getaddrinfo(EAI_BADFLAGS)"));
230 if (server
->address_info
)
232 freeaddrinfo(server
->address_info
);
233 server
->address_info
= NULL
;
234 server
->address_info_next
= NULL
;
236 return memcached_set_error(*server
, MEMCACHED_MEMORY_ALLOCATION_FAILURE
, MEMCACHED_AT
, memcached_literal_param("getaddrinfo(EAI_MEMORY)"));
240 if (server
->address_info
)
242 freeaddrinfo(server
->address_info
);
243 server
->address_info
= NULL
;
244 server
->address_info_next
= NULL
;
246 return memcached_set_error(*server
, MEMCACHED_HOST_LOOKUP_FAILURE
, MEMCACHED_AT
, memcached_string_make_from_cstr(gai_strerror(errcode
)));
249 server
->address_info_next
= server
->address_info
;
250 server
->state
= MEMCACHED_SERVER_STATE_ADDRINFO
;
252 return MEMCACHED_SUCCESS
;
255 static inline void set_socket_nonblocking(org::libmemcached::Instance
* server
)
259 if (ioctlsocket(server
->fd
, FIONBIO
, &arg
) == SOCKET_ERROR
)
261 memcached_set_errno(*server
, get_socket_errno(), NULL
);
266 if (SOCK_NONBLOCK
== 0)
270 flags
= fcntl(server
->fd
, F_GETFL
, 0);
271 } while (flags
== -1 && (errno
== EINTR
|| errno
== EAGAIN
));
275 memcached_set_errno(*server
, errno
, NULL
);
277 else if ((flags
& O_NONBLOCK
) == 0)
283 rval
= fcntl(server
->fd
, F_SETFL
, flags
| O_NONBLOCK
);
284 } while (rval
== -1 && (errno
== EINTR
or errno
== EAGAIN
));
288 memcached_set_errno(*server
, errno
, NULL
);
295 static bool set_socket_options(org::libmemcached::Instance
* server
)
297 assert_msg(server
->fd
!= INVALID_SOCKET
, "invalid socket was passed to set_socket_options()");
300 // If SOCK_CLOEXEC exists then we don't need to call the following
301 if (SOCK_CLOEXEC
== 0)
308 flags
= fcntl(server
->fd
, F_GETFD
, 0);
309 } while (flags
== -1 and (errno
== EINTR
or errno
== EAGAIN
));
316 rval
= fcntl (server
->fd
, F_SETFD
, flags
| FD_CLOEXEC
);
317 } while (rval
== -1 && (errno
== EINTR
or errno
== EAGAIN
));
318 // we currently ignore the case where rval is -1
324 if (memcached_is_udp(server
->root
))
330 if (server
->root
->snd_timeout
> 0)
332 struct timeval waittime
;
334 waittime
.tv_sec
= server
->root
->snd_timeout
/ 1000000;
335 waittime
.tv_usec
= server
->root
->snd_timeout
% 1000000;
337 int error
= setsockopt(server
->fd
, SOL_SOCKET
, SO_SNDTIMEO
,
338 (char*)&waittime
, (socklen_t
)sizeof(struct timeval
));
345 if (server
->root
->rcv_timeout
> 0)
347 struct timeval waittime
;
349 waittime
.tv_sec
= server
->root
->rcv_timeout
/ 1000000;
350 waittime
.tv_usec
= server
->root
->rcv_timeout
% 1000000;
352 int error
= setsockopt(server
->fd
, SOL_SOCKET
, SO_RCVTIMEO
,
353 (char*)&waittime
, (socklen_t
)sizeof(struct timeval
));
362 #if defined(SO_NOSIGPIPE)
366 int error
= setsockopt(server
->fd
, SOL_SOCKET
, SO_NOSIGPIPE
, (void *)&set
, sizeof(int));
370 // This is not considered a fatal error
374 perror("setsockopt(SO_NOSIGPIPE)");
378 #endif // SO_NOSIGPIPE
381 if (server
->root
->flags
.no_block
)
383 struct linger linger
;
386 linger
.l_linger
= 0; /* By default on close() just drop the socket */
387 int error
= setsockopt(server
->fd
, SOL_SOCKET
, SO_LINGER
,
388 (char*)&linger
, (socklen_t
)sizeof(struct linger
));
395 if (server
->root
->flags
.tcp_nodelay
)
399 int error
= setsockopt(server
->fd
, IPPROTO_TCP
, TCP_NODELAY
,
400 (char*)&flag
, (socklen_t
)sizeof(int));
406 if (server
->root
->flags
.tcp_keepalive
)
410 int error
= setsockopt(server
->fd
, SOL_SOCKET
, SO_KEEPALIVE
,
411 (char*)&flag
, (socklen_t
)sizeof(int));
418 if (server
->root
->tcp_keepidle
> 0)
420 int error
= setsockopt(server
->fd
, IPPROTO_TCP
, TCP_KEEPIDLE
,
421 (char*)&server
->root
->tcp_keepidle
, (socklen_t
)sizeof(int));
427 if (server
->root
->send_size
> 0)
429 int error
= setsockopt(server
->fd
, SOL_SOCKET
, SO_SNDBUF
,
430 (char*)&server
->root
->send_size
, (socklen_t
)sizeof(int));
435 if (server
->root
->recv_size
> 0)
437 int error
= setsockopt(server
->fd
, SOL_SOCKET
, SO_RCVBUF
,
438 (char*)&server
->root
->recv_size
, (socklen_t
)sizeof(int));
443 /* libmemcached will always use nonblocking IO to avoid write deadlocks */
444 set_socket_nonblocking(server
);
449 static memcached_return_t
unix_socket_connect(org::libmemcached::Instance
* server
)
452 WATCHPOINT_ASSERT(server
->fd
== INVALID_SOCKET
);
455 int type
= SOCK_STREAM
;
463 type
|= SOCK_NONBLOCK
;
466 if ((server
->fd
= socket(AF_UNIX
, type
, 0)) < 0)
468 return memcached_set_errno(*server
, errno
, NULL
);
471 struct sockaddr_un servAddr
;
473 memset(&servAddr
, 0, sizeof (struct sockaddr_un
));
474 servAddr
.sun_family
= AF_UNIX
;
475 strncpy(servAddr
.sun_path
, server
->hostname
, sizeof(servAddr
.sun_path
)); /* Copy filename */
477 if (connect(server
->fd
, (struct sockaddr
*)&servAddr
, sizeof(servAddr
)) < 0)
483 server
->events(POLLOUT
);
487 (void)closesocket(server
->fd
);
488 server
->fd
= INVALID_SOCKET
;
491 case EISCONN
: /* We were spinning waiting on connect */
493 assert(0); // Programmer error
494 (void)closesocket(server
->fd
);
495 server
->fd
= INVALID_SOCKET
;
500 WATCHPOINT_ERRNO(errno
);
501 (void)closesocket(server
->fd
);
502 server
->fd
= INVALID_SOCKET
;
503 return memcached_set_errno(*server
, errno
, MEMCACHED_AT
);
507 server
->state
= MEMCACHED_SERVER_STATE_CONNECTED
;
509 WATCHPOINT_ASSERT(server
->fd
!= INVALID_SOCKET
);
511 return MEMCACHED_SUCCESS
;
514 return MEMCACHED_NOT_SUPPORTED
;
518 static memcached_return_t
network_connect(org::libmemcached::Instance
* server
)
520 bool timeout_error_occured
= false;
522 WATCHPOINT_ASSERT(server
->fd
== INVALID_SOCKET
);
523 WATCHPOINT_ASSERT(server
->cursor_active_
== 0);
526 We want to check both of these because if address_info_next has been fully tried, we want to do a new lookup to make sure we have picked up on any new DNS information.
528 if (server
->address_info
== NULL
or server
->address_info_next
== NULL
)
530 WATCHPOINT_ASSERT(server
->state
== MEMCACHED_SERVER_STATE_NEW
);
531 server
->address_info_next
= NULL
;
532 memcached_return_t rc
= set_hostinfo(server
);
534 if (memcached_failed(rc
))
540 if (server
->address_info_next
== NULL
)
542 server
->address_info_next
= server
->address_info
;
543 server
->state
= MEMCACHED_SERVER_STATE_ADDRINFO
;
546 /* Create the socket */
547 while (server
->address_info_next
and server
->fd
== INVALID_SOCKET
)
549 /* Memcache server does not support IPV6 in udp mode, so skip if not ipv4 */
550 if (memcached_is_udp(server
->root
) and server
->address_info_next
->ai_family
!= AF_INET
)
552 server
->address_info_next
= server
->address_info_next
->ai_next
;
556 int type
= server
->address_info_next
->ai_socktype
;
564 type
|= SOCK_NONBLOCK
;
567 server
->fd
= socket(server
->address_info_next
->ai_family
,
569 server
->address_info_next
->ai_protocol
);
571 if (int(server
->fd
) == SOCKET_ERROR
)
573 return memcached_set_errno(*server
, get_socket_errno(), NULL
);
576 if (set_socket_options(server
) == false)
578 (void)closesocket(server
->fd
);
579 return MEMCACHED_CONNECTION_FAILURE
;
582 /* connect to server */
583 if ((connect(server
->fd
, server
->address_info_next
->ai_addr
, server
->address_info_next
->ai_addrlen
) != SOCKET_ERROR
))
585 server
->state
= MEMCACHED_SERVER_STATE_CONNECTED
;
586 return MEMCACHED_SUCCESS
;
589 /* An error occurred */
590 switch (get_socket_errno())
593 timeout_error_occured
= true;
597 #if EWOULDBLOCK != EAGAIN
600 case EINPROGRESS
: // nonblocking mode - first return
601 case EALREADY
: // nonblocking mode - subsequent returns
603 server
->events(POLLOUT
);
604 server
->state
= MEMCACHED_SERVER_STATE_IN_PROGRESS
;
605 memcached_return_t rc
= connect_poll(server
);
607 if (memcached_success(rc
))
609 server
->state
= MEMCACHED_SERVER_STATE_CONNECTED
;
610 return MEMCACHED_SUCCESS
;
613 // A timeout here is treated as an error, we will not retry
614 if (rc
== MEMCACHED_TIMEOUT
)
616 timeout_error_occured
= true;
621 case EISCONN
: // we are connected :-)
622 WATCHPOINT_ASSERT(0); // This is a programmer's error
625 case EINTR
: // Special case, we retry ai_addr
626 WATCHPOINT_ASSERT(server
->fd
!= INVALID_SOCKET
);
627 (void)closesocket(server
->fd
);
628 server
->fd
= INVALID_SOCKET
;
632 // Probably not running service
638 WATCHPOINT_ASSERT(server
->fd
!= INVALID_SOCKET
);
639 (void)closesocket(server
->fd
);
640 server
->fd
= INVALID_SOCKET
;
641 server
->address_info_next
= server
->address_info_next
->ai_next
;
644 WATCHPOINT_ASSERT(server
->fd
== INVALID_SOCKET
);
646 if (timeout_error_occured
)
648 if (server
->fd
!= INVALID_SOCKET
)
650 (void)closesocket(server
->fd
);
651 server
->fd
= INVALID_SOCKET
;
655 WATCHPOINT_STRING("Never got a good file descriptor");
657 if (memcached_has_current_error(*server
))
659 return memcached_instance_error_return(server
);
662 if (timeout_error_occured
and server
->state
< MEMCACHED_SERVER_STATE_IN_PROGRESS
)
664 return memcached_set_error(*server
, MEMCACHED_TIMEOUT
, MEMCACHED_AT
);
667 return memcached_set_error(*server
, MEMCACHED_CONNECTION_FAILURE
, MEMCACHED_AT
); /* The last error should be from connect() */
674 Based on time/failure count fail the connect without trying. This prevents waiting in a state where
675 we get caught spending cycles just waiting.
677 static memcached_return_t
backoff_handling(org::libmemcached::Instance
* server
, bool& in_timeout
)
679 struct timeval curr_time
;
680 bool _gettime_success
= (gettimeofday(&curr_time
, NULL
) == 0);
683 If we hit server_failure_limit then something is completely wrong about the server.
685 1) If autoeject is enabled we do that.
686 2) If not? We go into timeout again, there is much else to do :(
688 if (server
->server_failure_counter
>= server
->root
->server_failure_limit
)
691 We just auto_eject if we hit this point
693 if (_is_auto_eject_host(server
->root
))
695 set_last_disconnected_host(server
);
697 // Retry dead servers if requested
698 if (_gettime_success
and server
->root
->dead_timeout
> 0)
700 server
->next_retry
= curr_time
.tv_sec
+server
->root
->dead_timeout
;
702 // We only retry dead servers once before assuming failure again
703 server
->server_failure_counter
= server
->root
->server_failure_limit
-1;
706 memcached_return_t rc
;
707 if (memcached_failed(rc
= run_distribution((memcached_st
*)server
->root
)))
709 return memcached_set_error(*server
, rc
, MEMCACHED_AT
, memcached_literal_param("Backoff handling failed during run_distribution"));
712 return memcached_set_error(*server
, MEMCACHED_SERVER_MARKED_DEAD
, MEMCACHED_AT
);
715 server
->state
= MEMCACHED_SERVER_STATE_IN_TIMEOUT
;
717 // Sanity check/setting
718 if (server
->next_retry
== 0)
720 server
->next_retry
= 1;
724 if (server
->state
== MEMCACHED_SERVER_STATE_IN_TIMEOUT
)
727 If next_retry is less then our current time, then we reset and try everything again.
729 if (_gettime_success
and server
->next_retry
< curr_time
.tv_sec
)
731 server
->state
= MEMCACHED_SERVER_STATE_NEW
;
735 return memcached_set_error(*server
, MEMCACHED_SERVER_TEMPORARILY_DISABLED
, MEMCACHED_AT
);
741 return MEMCACHED_SUCCESS
;
744 static memcached_return_t
_memcached_connect(org::libmemcached::Instance
* server
, const bool set_last_disconnected
)
747 if (server
->fd
!= INVALID_SOCKET
)
749 return MEMCACHED_SUCCESS
;
752 LIBMEMCACHED_MEMCACHED_CONNECT_START();
754 bool in_timeout
= false;
755 memcached_return_t rc
;
756 if (memcached_failed(rc
= backoff_handling(server
, in_timeout
)))
758 set_last_disconnected_host(server
);
762 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and server
->root
->sasl
.callbacks
and memcached_is_udp(server
->root
))
764 return memcached_set_error(*server
, MEMCACHED_INVALID_HOST_PROTOCOL
, MEMCACHED_AT
, memcached_literal_param("SASL is not supported for UDP connections"));
767 if (server
->hostname
[0] == '/')
769 server
->type
= MEMCACHED_CONNECTION_UNIX_SOCKET
;
772 /* We need to clean up the multi startup piece */
773 switch (server
->type
)
775 case MEMCACHED_CONNECTION_UDP
:
776 case MEMCACHED_CONNECTION_TCP
:
777 rc
= network_connect(server
);
779 if (LIBMEMCACHED_WITH_SASL_SUPPORT
)
781 if (server
->fd
!= INVALID_SOCKET
and server
->root
->sasl
.callbacks
)
783 rc
= memcached_sasl_authenticate_connection(server
);
784 fprintf(stderr
, "%s:%d %s\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, rc
));
785 if (memcached_failed(rc
) and server
->fd
!= INVALID_SOCKET
)
787 WATCHPOINT_ASSERT(server
->fd
!= INVALID_SOCKET
);
788 (void)closesocket(server
->fd
);
789 server
->fd
= INVALID_SOCKET
;
795 case MEMCACHED_CONNECTION_UNIX_SOCKET
:
796 rc
= unix_socket_connect(server
);
800 if (memcached_success(rc
))
802 server
->mark_server_as_clean();
803 memcached_version_instance(server
);
806 else if (set_last_disconnected
)
808 set_last_disconnected_host(server
);
809 if (memcached_has_current_error(*server
))
811 memcached_mark_server_for_timeout(server
);
812 assert(memcached_failed(memcached_instance_error_return(server
)));
816 memcached_set_error(*server
, rc
, MEMCACHED_AT
);
817 memcached_mark_server_for_timeout(server
);
820 LIBMEMCACHED_MEMCACHED_CONNECT_END();
825 int snprintf_length
= snprintf(buffer
, sizeof(buffer
), "%s:%d", server
->hostname
, int(server
->port()));
826 return memcached_set_error(*server
, MEMCACHED_SERVER_TEMPORARILY_DISABLED
, MEMCACHED_AT
, buffer
, snprintf_length
);
833 memcached_return_t
memcached_connect(org::libmemcached::Instance
* server
)
835 return _memcached_connect(server
, true);