2 +--------------------------------------------------------------------+
3 | libmemcached - C/C++ Client Library for memcached |
4 +--------------------------------------------------------------------+
5 | Redistribution and use in source and binary forms, with or without |
6 | modification, are permitted under the terms of the BSD license. |
7 | You should have received a copy of the license in a bundled file |
8 | named LICENSE; in case you did not receive a copy you can review |
9 | the terms online at: https://opensource.org/licenses/BSD-3-Clause |
10 +--------------------------------------------------------------------+
11 | Copyright (c) 2006-2014 Brian Aker https://datadifferential.com/ |
12 | Copyright (c) 2020 Michael Wallner <mike@php.net> |
13 +--------------------------------------------------------------------+
16 #include "libmemcached/common.h"
18 static inline void _server_init(memcached_server_st
*self
, Memcached
*root
,
19 const memcached_string_t
&hostname
, in_port_t port
, uint32_t weight
,
20 memcached_connection_t type
) {
21 self
->options
.is_shutting_down
= false;
22 self
->options
.is_dead
= false;
23 self
->number_of_hosts
= 0;
24 self
->cursor_active
= 0;
26 self
->io_bytes_sent
= 0;
28 self
->server_failure_counter
= 0;
29 self
->server_failure_counter_query_id
= 0;
30 self
->server_timeout_counter
= 0;
31 self
->server_timeout_counter_query_id
= 0;
32 self
->weight
= weight
? weight
: 1; // 1 is the default weight value
33 self
->io_wait_count
.read
= 0;
34 self
->io_wait_count
.write
= 0;
35 self
->io_wait_count
.timeouts
= 0;
36 self
->io_wait_count
._bytes_read
= 0;
37 self
->major_version
= UINT8_MAX
;
38 self
->micro_version
= UINT8_MAX
;
39 self
->minor_version
= UINT8_MAX
;
41 self
->error_messages
= NULL
;
43 self
->state
= MEMCACHED_SERVER_STATE_NEW
;
48 self
->version
= ++root
->server_info
.version
;
50 self
->version
= UINT_MAX
;
52 self
->limit_maxbytes
= 0;
53 memcpy(self
->hostname
, hostname
.c_str
, hostname
.size
);
54 self
->hostname
[hostname
.size
] = 0;
57 static memcached_server_st
*_server_create(memcached_server_st
*self
, const Memcached
*memc
) {
59 self
= libmemcached_xmalloc(memc
, struct memcached_server_st
);
62 return NULL
; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */
65 self
->options
.is_allocated
= true;
67 self
->options
.is_allocated
= false;
70 self
->options
.is_initialized
= true;
75 memcached_server_st
*server_create_with(Memcached
*memc
, memcached_server_st
*self
,
76 const memcached_string_t
&hostname
, const in_port_t port
,
77 uint32_t weight
, const memcached_connection_t type
) {
78 if (memcached_is_valid_servername(hostname
) == false) {
79 memcached_set_error(*memc
, MEMCACHED_INVALID_ARGUMENTS
, MEMCACHED_AT
,
80 memcached_literal_param("Invalid hostname provided"));
84 self
= _server_create(self
, memc
);
90 _server_init(self
, const_cast<Memcached
*>(memc
), hostname
, port
, weight
, type
);
95 void server_free(memcached_server_st
*self
) {
96 memcached_error_free(*self
);
98 if (memcached_is_allocated(self
)) {
99 libmemcached_free(self
->root
, self
);
101 self
->options
.is_initialized
= false;
105 void memcached_server_free(memcached_server_st
*self
) {
110 if (memcached_server_list_count(self
)) {
111 memcached_server_list_free(self
);
118 void memcached_server_error_reset(memcached_server_st
*self
) {
119 WATCHPOINT_ASSERT(self
);
124 memcached_error_free(*self
);
127 uint32_t memcached_servers_set_count(memcached_server_st
*servers
, uint32_t count
) {
128 WATCHPOINT_ASSERT(servers
);
129 if (servers
== NULL
) {
133 return servers
->number_of_hosts
= count
;
136 uint32_t memcached_server_count(const memcached_st
*self
) {
137 WATCHPOINT_ASSERT(self
);
141 return self
->number_of_hosts
;
144 const char *memcached_server_name(const memcached_instance_st
*self
) {
145 WATCHPOINT_ASSERT(self
);
147 return self
->_hostname
;
153 in_port_t
memcached_server_port(const memcached_instance_st
*self
) {
154 WATCHPOINT_ASSERT(self
);
162 in_port_t
memcached_server_srcport(const memcached_instance_st
*self
) {
163 WATCHPOINT_ASSERT(self
);
164 if (self
== NULL
|| self
->fd
== INVALID_SOCKET
165 || (self
->type
!= MEMCACHED_CONNECTION_TCP
&& self
->type
!= MEMCACHED_CONNECTION_UDP
))
170 struct sockaddr_in sin
;
171 socklen_t addrlen
= sizeof(sin
);
172 if (getsockname(self
->fd
, (struct sockaddr
*) &sin
, &addrlen
) != -1) {
173 return ntohs(sin
.sin_port
);
179 uint32_t memcached_server_response_count(const memcached_instance_st
*self
) {
180 WATCHPOINT_ASSERT(self
);
185 return self
->cursor_active_
;
188 const char *memcached_server_type(const memcached_instance_st
*ptr
) {
191 case MEMCACHED_CONNECTION_TCP
:
194 case MEMCACHED_CONNECTION_UDP
:
197 case MEMCACHED_CONNECTION_UNIX_SOCKET
:
205 uint8_t memcached_server_major_version(const memcached_instance_st
*instance
) {
207 return instance
->major_version
;
213 uint8_t memcached_server_minor_version(const memcached_instance_st
*instance
) {
215 return instance
->minor_version
;
221 uint8_t memcached_server_micro_version(const memcached_instance_st
*instance
) {
223 return instance
->micro_version
;