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 static memcached_return_t
connect_poll(memcached_server_st
*ptr
)
48 fds
[0].events
= POLLOUT
;
53 while (--loop_max
) // Should only loop on cases of ERESTART or EINTR
55 error
= poll(fds
, 1, ptr
->root
->connect_timeout
);
62 socklen_t len
= sizeof (err
);
63 (void)getsockopt(ptr
->fd
, SOL_SOCKET
, SO_ERROR
, &err
, &len
);
65 // We check the value to see what happened wth the socket.
68 return MEMCACHED_SUCCESS
;
72 ptr
->cached_errno
= errno
;
74 return MEMCACHED_ERRNO
;
78 return MEMCACHED_TIMEOUT
;
79 default: // A real error occurred and we need to completely bail
80 WATCHPOINT_ERRNO(get_socket_errno());
81 switch (get_socket_errno())
83 #ifdef TARGET_OS_LINUX
89 if (fds
[0].revents
& POLLERR
)
92 socklen_t len
= sizeof (err
);
93 (void)getsockopt(ptr
->fd
, SOL_SOCKET
, SO_ERROR
, &err
, &len
);
94 ptr
->cached_errno
= (err
== 0) ? get_socket_errno() : err
;
98 ptr
->cached_errno
= get_socket_errno();
101 (void)closesocket(ptr
->fd
);
102 ptr
->fd
= INVALID_SOCKET
;
104 return MEMCACHED_ERRNO
;
109 // This should only be possible from ERESTART or EINTR;
110 ptr
->cached_errno
= get_socket_errno();
112 return MEMCACHED_ERRNO
;
115 static memcached_return_t
set_hostinfo(memcached_server_st
*server
)
117 char str_port
[NI_MAXSERV
];
119 assert(! server
->address_info
); // We cover the case where a programming mistake has been made.
120 if (server
->address_info
)
122 freeaddrinfo(server
->address_info
);
123 server
->address_info
= NULL
;
124 server
->address_info_next
= NULL
;
127 int length
= snprintf(str_port
, NI_MAXSERV
, "%u", (uint32_t)server
->port
);
128 if (length
>= NI_MAXSERV
|| length
< 0)
129 return MEMCACHED_FAILURE
;
131 struct addrinfo hints
;
132 memset(&hints
, 0, sizeof(struct addrinfo
));
135 hints
.ai_family
= AF_INET
;
137 if (server
->type
== MEMCACHED_CONNECTION_UDP
)
139 hints
.ai_protocol
= IPPROTO_UDP
;
140 hints
.ai_socktype
= SOCK_DGRAM
;
144 hints
.ai_socktype
= SOCK_STREAM
;
145 hints
.ai_protocol
= IPPROTO_TCP
;
151 int e
= getaddrinfo(server
->hostname
, str_port
, &hints
, &server
->address_info
);
157 else if (e
== EAI_AGAIN
)
160 struct timespec dream
, rem
;
165 nanosleep(&dream
, &rem
);
171 WATCHPOINT_STRING(server
->hostname
);
172 WATCHPOINT_STRING(gai_strerror(e
));
173 return MEMCACHED_HOST_LOOKUP_FAILURE
;
177 server
->address_info_next
= server
->address_info
;
179 return MEMCACHED_SUCCESS
;
182 static inline memcached_return_t
set_socket_nonblocking(memcached_server_st
*ptr
)
186 if (ioctlsocket(ptr
->fd
, FIONBIO
, &arg
) == SOCKET_ERROR
)
188 ptr
->cached_errno
= get_socket_errno();
189 return MEMCACHED_CONNECTION_FAILURE
;
196 flags
= fcntl(ptr
->fd
, F_GETFL
, 0);
198 while (flags
== -1 && (errno
== EINTR
|| errno
== EAGAIN
));
200 unlikely (flags
== -1)
202 ptr
->cached_errno
= errno
;
203 return MEMCACHED_CONNECTION_FAILURE
;
205 else if ((flags
& O_NONBLOCK
) == 0)
211 rval
= fcntl(ptr
->fd
, F_SETFL
, flags
| O_NONBLOCK
);
213 while (rval
== -1 && (errno
== EINTR
|| errno
== EAGAIN
));
215 unlikely (rval
== -1)
217 ptr
->cached_errno
= errno
;
218 return MEMCACHED_CONNECTION_FAILURE
;
222 return MEMCACHED_SUCCESS
;
225 static memcached_return_t
set_socket_options(memcached_server_st
*ptr
)
227 WATCHPOINT_ASSERT(ptr
->fd
!= -1);
229 if (ptr
->type
== MEMCACHED_CONNECTION_UDP
)
230 return MEMCACHED_SUCCESS
;
233 if (ptr
->root
->snd_timeout
)
236 struct timeval waittime
;
239 waittime
.tv_usec
= ptr
->root
->snd_timeout
;
241 error
= setsockopt(ptr
->fd
, SOL_SOCKET
, SO_SNDTIMEO
,
242 &waittime
, (socklen_t
)sizeof(struct timeval
));
243 WATCHPOINT_ASSERT(error
== 0);
245 return MEMCACHED_FAILURE
;
250 if (ptr
->root
->rcv_timeout
)
253 struct timeval waittime
;
256 waittime
.tv_usec
= ptr
->root
->rcv_timeout
;
258 error
= setsockopt(ptr
->fd
, SOL_SOCKET
, SO_RCVTIMEO
,
259 &waittime
, (socklen_t
)sizeof(struct timeval
));
260 WATCHPOINT_ASSERT(error
== 0);
262 return MEMCACHED_FAILURE
;
267 #if defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
270 int error
= setsockopt(ptr
->fd
, SOL_SOCKET
, SO_NOSIGPIPE
, (void *)&set
, sizeof(int));
272 // This is not considered a fatal error
275 WATCHPOINT_ERRNO(get_socket_errno());
276 perror("setsockopt(SO_NOSIGPIPE)");
281 if (ptr
->root
->flags
.no_block
)
284 struct linger linger
;
287 linger
.l_linger
= 0; /* By default on close() just drop the socket */
288 error
= setsockopt(ptr
->fd
, SOL_SOCKET
, SO_LINGER
,
289 &linger
, (socklen_t
)sizeof(struct linger
));
290 WATCHPOINT_ASSERT(error
== 0);
292 return MEMCACHED_FAILURE
;
295 if (ptr
->root
->flags
.tcp_nodelay
)
300 error
= setsockopt(ptr
->fd
, IPPROTO_TCP
, TCP_NODELAY
,
301 &flag
, (socklen_t
)sizeof(int));
302 WATCHPOINT_ASSERT(error
== 0);
304 return MEMCACHED_FAILURE
;
307 if (ptr
->root
->flags
.tcp_keepalive
)
312 error
= setsockopt(ptr
->fd
, SOL_SOCKET
, SO_KEEPALIVE
,
313 &flag
, (socklen_t
)sizeof(int));
314 WATCHPOINT_ASSERT(error
== 0);
316 return MEMCACHED_FAILURE
;
320 if (ptr
->root
->tcp_keepidle
> 0)
324 error
= setsockopt(ptr
->fd
, IPPROTO_TCP
, TCP_KEEPIDLE
,
325 &ptr
->root
->tcp_keepidle
, (socklen_t
)sizeof(int));
326 WATCHPOINT_ASSERT(error
== 0);
328 return MEMCACHED_FAILURE
;
332 if (ptr
->root
->send_size
> 0)
336 error
= setsockopt(ptr
->fd
, SOL_SOCKET
, SO_SNDBUF
,
337 &ptr
->root
->send_size
, (socklen_t
)sizeof(int));
338 WATCHPOINT_ASSERT(error
== 0);
340 return MEMCACHED_FAILURE
;
343 if (ptr
->root
->recv_size
> 0)
347 error
= setsockopt(ptr
->fd
, SOL_SOCKET
, SO_RCVBUF
,
348 &ptr
->root
->recv_size
, (socklen_t
)sizeof(int));
349 WATCHPOINT_ASSERT(error
== 0);
351 return MEMCACHED_FAILURE
;
355 /* libmemcached will always use nonblocking IO to avoid write deadlocks */
356 return set_socket_nonblocking(ptr
);
359 static memcached_return_t
unix_socket_connect(memcached_server_st
*ptr
)
362 WATCHPOINT_ASSERT(ptr
->fd
== -1);
364 if ((ptr
->fd
= socket(AF_UNIX
, SOCK_STREAM
, 0)) < 0)
366 ptr
->cached_errno
= errno
;
367 return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE
;
370 struct sockaddr_un servAddr
;
372 memset(&servAddr
, 0, sizeof (struct sockaddr_un
));
373 servAddr
.sun_family
= AF_UNIX
;
374 strncpy(servAddr
.sun_path
, ptr
->hostname
, sizeof(servAddr
.sun_path
)); /* Copy filename */
378 (struct sockaddr
*)&servAddr
,
379 sizeof(servAddr
)) < 0)
387 case EISCONN
: /* We were spinning waiting on connect */
390 WATCHPOINT_ERRNO(errno
);
391 ptr
->cached_errno
= errno
;
392 return MEMCACHED_ERRNO
;
396 WATCHPOINT_ASSERT(ptr
->fd
!= -1);
398 return MEMCACHED_SUCCESS
;
401 return MEMCACHED_NOT_SUPPORTED
;
405 static memcached_return_t
network_connect(memcached_server_st
*ptr
)
407 bool timeout_error_occured
= false;
409 WATCHPOINT_ASSERT(ptr
->fd
== INVALID_SOCKET
);
410 WATCHPOINT_ASSERT(ptr
->cursor_active
== 0);
412 if (! ptr
->address_info
)
414 memcached_return_t rc
= set_hostinfo(ptr
);
415 if (rc
!= MEMCACHED_SUCCESS
)
419 /* Create the socket */
420 while (ptr
->address_info_next
&& ptr
->fd
== INVALID_SOCKET
)
422 /* Memcache server does not support IPV6 in udp mode, so skip if not ipv4 */
423 if (ptr
->type
== MEMCACHED_CONNECTION_UDP
&& ptr
->address_info_next
->ai_family
!= AF_INET
)
425 ptr
->address_info_next
= ptr
->address_info_next
->ai_next
;
429 if ((ptr
->fd
= socket(ptr
->address_info_next
->ai_family
,
430 ptr
->address_info_next
->ai_socktype
,
431 ptr
->address_info_next
->ai_protocol
)) < 0)
433 ptr
->cached_errno
= get_socket_errno();
434 WATCHPOINT_ERRNO(get_socket_errno());
435 return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE
;
438 (void)set_socket_options(ptr
);
440 /* connect to server */
441 if ((connect(ptr
->fd
, ptr
->address_info_next
->ai_addr
, ptr
->address_info_next
->ai_addrlen
) != SOCKET_ERROR
))
446 /* An error occurred */
447 ptr
->cached_errno
= get_socket_errno();
448 switch (ptr
->cached_errno
)
451 case EINPROGRESS
: // nonblocking mode - first return
452 case EALREADY
: // nonblocking mode - subsequent returns
454 memcached_return_t rc
;
455 rc
= connect_poll(ptr
);
457 if (rc
== MEMCACHED_TIMEOUT
)
458 timeout_error_occured
= true;
460 if (rc
== MEMCACHED_SUCCESS
)
464 case EISCONN
: // we are connected :-)
467 case EINTR
: // Special case, we retry ai_addr
468 (void)closesocket(ptr
->fd
);
469 ptr
->fd
= INVALID_SOCKET
;
473 (void)closesocket(ptr
->fd
);
474 ptr
->fd
= INVALID_SOCKET
;
475 ptr
->address_info_next
= ptr
->address_info_next
->ai_next
;
480 if (ptr
->fd
== INVALID_SOCKET
)
482 WATCHPOINT_STRING("Never got a good file descriptor");
484 /* Failed to connect. schedule next retry */
485 if (ptr
->root
->retry_timeout
)
487 struct timeval next_time
;
489 if (gettimeofday(&next_time
, NULL
) == 0)
490 ptr
->next_retry
= next_time
.tv_sec
+ ptr
->root
->retry_timeout
;
493 if (timeout_error_occured
)
494 return MEMCACHED_TIMEOUT
;
496 return MEMCACHED_ERRNO
; /* The last error should be from connect() */
499 return MEMCACHED_SUCCESS
; /* The last error should be from connect() */
502 void set_last_disconnected_host(memcached_server_write_instance_st ptr
)
505 memcached_st
*root
= (memcached_st
*)ptr
->root
;
508 WATCHPOINT_STRING(ptr
->hostname
);
509 WATCHPOINT_NUMBER(ptr
->port
);
510 WATCHPOINT_ERRNO(ptr
->cached_errno
);
512 if (root
->last_disconnected_server
)
513 memcached_server_free(root
->last_disconnected_server
);
514 root
->last_disconnected_server
= memcached_server_clone(NULL
, ptr
);
517 memcached_return_t
memcached_connect(memcached_server_write_instance_st ptr
)
519 memcached_return_t rc
= MEMCACHED_NO_SERVERS
;
521 if (ptr
->fd
!= INVALID_SOCKET
)
522 return MEMCACHED_SUCCESS
;
524 LIBMEMCACHED_MEMCACHED_CONNECT_START();
526 /* both retry_timeout and server_failure_limit must be set in order to delay retrying a server on error. */
527 WATCHPOINT_ASSERT(ptr
->root
);
528 if (ptr
->root
->retry_timeout
&& ptr
->next_retry
)
530 struct timeval curr_time
;
532 gettimeofday(&curr_time
, NULL
);
534 // We should optimize this to remove the allocation if the server was
535 // the last server to die
536 if (ptr
->next_retry
> curr_time
.tv_sec
)
538 set_last_disconnected_host(ptr
);
540 return MEMCACHED_SERVER_MARKED_DEAD
;
544 // If we are over the counter failure, we just fail. Reject host only
545 // works if you have a set number of failures.
546 if (ptr
->root
->server_failure_limit
&& ptr
->server_failure_counter
>= ptr
->root
->server_failure_limit
)
548 set_last_disconnected_host(ptr
);
550 // @todo fix this by fixing behavior to no longer make use of
552 if (_is_auto_eject_host(ptr
->root
))
554 run_distribution((memcached_st
*)ptr
->root
);
557 return MEMCACHED_SERVER_MARKED_DEAD
;
560 /* We need to clean up the multi startup piece */
563 case MEMCACHED_CONNECTION_UNKNOWN
:
564 WATCHPOINT_ASSERT(0);
565 rc
= MEMCACHED_NOT_SUPPORTED
;
567 case MEMCACHED_CONNECTION_UDP
:
568 case MEMCACHED_CONNECTION_TCP
:
569 rc
= network_connect(ptr
);
570 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
571 if (ptr
->fd
!= INVALID_SOCKET
&& ptr
->root
->sasl
.callbacks
)
573 rc
= memcached_sasl_authenticate_connection(ptr
);
574 if (rc
!= MEMCACHED_SUCCESS
)
576 (void)closesocket(ptr
->fd
);
577 ptr
->fd
= INVALID_SOCKET
;
582 case MEMCACHED_CONNECTION_UNIX_SOCKET
:
583 rc
= unix_socket_connect(ptr
);
585 case MEMCACHED_CONNECTION_MAX
:
587 WATCHPOINT_ASSERT(0);
590 if (rc
== MEMCACHED_SUCCESS
)
592 ptr
->server_failure_counter
= 0;
597 ptr
->server_failure_counter
++;
599 set_last_disconnected_host(ptr
);
602 LIBMEMCACHED_MEMCACHED_CONNECT_END();