don't convert between 16 and 32 bit when you don't need to
[m6w6/libmemcached] / libmemcached / memcached.c
1 /*
2 Memcached library
3 */
4 #include "common.h"
5
6 memcached_st *memcached_create(memcached_st *ptr)
7 {
8 if (ptr == NULL)
9 {
10 ptr= (memcached_st *)calloc(1, sizeof(memcached_st));
11
12 if (! ptr)
13 {
14 return NULL; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */
15 }
16
17 ptr->options.is_allocated= true;
18 }
19 else
20 {
21 memset(ptr, 0, sizeof(memcached_st));
22 }
23
24 ptr->options.is_initialized= true;
25
26 memcached_set_memory_allocators(ptr, NULL, NULL, NULL, NULL);
27
28 if (! memcached_result_create(ptr, &ptr->result))
29 {
30 memcached_free(ptr);
31 return NULL;
32 }
33 ptr->poll_timeout= MEMCACHED_DEFAULT_TIMEOUT;
34 ptr->connect_timeout= MEMCACHED_DEFAULT_TIMEOUT;
35 ptr->retry_timeout= 0;
36 ptr->distribution= MEMCACHED_DISTRIBUTION_MODULA;
37
38 /* TODO, Document why we picked these defaults */
39 ptr->io_msg_watermark= 500;
40 ptr->io_bytes_watermark= 65 * 1024;
41
42 WATCHPOINT_ASSERT_INITIALIZED(&ptr->result);
43
44 return ptr;
45 }
46
47 void server_list_free(memcached_st *ptr, memcached_server_st *servers)
48 {
49 uint32_t x;
50
51 if (servers == NULL)
52 return;
53
54 for (x= 0; x < memcached_servers_count(servers); x++)
55 if (servers[x].address_info)
56 {
57 freeaddrinfo(servers[x].address_info);
58 servers[x].address_info= NULL;
59 }
60
61 if (ptr)
62 {
63 ptr->call_free(ptr, servers);
64 }
65 else
66 free(servers);
67 }
68
69 void memcached_servers_reset(memcached_st *ptr)
70 {
71 server_list_free(ptr, ptr->hosts);
72
73 ptr->hosts= NULL;
74 ptr->number_of_hosts= 0;
75 ptr->last_disconnected_server= NULL;
76 ptr->server_failure_limit= 0;
77 }
78
79 void memcached_free(memcached_st *ptr)
80 {
81 /* If we have anything open, lets close it now */
82 memcached_quit(ptr);
83 server_list_free(ptr, ptr->hosts);
84 memcached_result_free(&ptr->result);
85
86 if (ptr->on_cleanup)
87 ptr->on_cleanup(ptr);
88
89 if (ptr->continuum)
90 ptr->call_free(ptr, ptr->continuum);
91
92 if (memcached_is_allocated(ptr))
93 {
94 ptr->call_free(ptr, ptr);
95 }
96 else
97 {
98 ptr->options.is_initialized= false;
99 }
100 }
101
102 /*
103 clone is the destination, while source is the structure to clone.
104 If source is NULL the call is the same as if a memcached_create() was
105 called.
106 */
107 memcached_st *memcached_clone(memcached_st *clone, memcached_st *source)
108 {
109 memcached_return_t rc= MEMCACHED_SUCCESS;
110 memcached_st *new_clone;
111
112 if (source == NULL)
113 return memcached_create(clone);
114
115 if (clone && memcached_is_allocated(clone))
116 {
117 return NULL;
118 }
119
120 new_clone= memcached_create(clone);
121
122 if (new_clone == NULL)
123 return NULL;
124
125 new_clone->flags= source->flags;
126 new_clone->send_size= source->send_size;
127 new_clone->recv_size= source->recv_size;
128 new_clone->poll_timeout= source->poll_timeout;
129 new_clone->connect_timeout= source->connect_timeout;
130 new_clone->retry_timeout= source->retry_timeout;
131 new_clone->distribution= source->distribution;
132 new_clone->hash= source->hash;
133 new_clone->distribution_hash= source->distribution_hash;
134 new_clone->user_data= source->user_data;
135
136 new_clone->snd_timeout= source->snd_timeout;
137 new_clone->rcv_timeout= source->rcv_timeout;
138
139 new_clone->on_clone= source->on_clone;
140 new_clone->on_cleanup= source->on_cleanup;
141 new_clone->call_free= source->call_free;
142 new_clone->call_malloc= source->call_malloc;
143 new_clone->call_realloc= source->call_realloc;
144 new_clone->call_calloc= source->call_calloc;
145 new_clone->get_key_failure= source->get_key_failure;
146 new_clone->delete_trigger= source->delete_trigger;
147 new_clone->server_failure_limit= source->server_failure_limit;
148 new_clone->io_msg_watermark= source->io_msg_watermark;
149 new_clone->io_bytes_watermark= source->io_bytes_watermark;
150 new_clone->io_key_prefetch= source->io_key_prefetch;
151 new_clone->number_of_replicas= source->number_of_replicas;
152
153 if (source->hosts)
154 rc= memcached_server_push(new_clone, source->hosts);
155
156 if (rc != MEMCACHED_SUCCESS)
157 {
158 memcached_free(new_clone);
159
160 return NULL;
161 }
162
163
164 if (source->prefix_key[0] != 0)
165 {
166 strcpy(new_clone->prefix_key, source->prefix_key);
167 new_clone->prefix_key_length= source->prefix_key_length;
168 }
169
170 rc= run_distribution(new_clone);
171
172 if (rc != MEMCACHED_SUCCESS)
173 {
174 memcached_free(new_clone);
175
176 return NULL;
177 }
178
179 if (source->on_clone)
180 source->on_clone(source, new_clone);
181
182 return new_clone;
183 }
184
185 void *memcached_get_user_data(memcached_st *ptr)
186 {
187 return ptr->user_data;
188 }
189
190 void *memcached_set_user_data(memcached_st *ptr, void *data)
191 {
192 void *ret= ptr->user_data;
193 ptr->user_data= data;
194
195 return ret;
196 }