2 * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * $FreeBSD: src/lib/libc/net/nscache.c,v 1.2 2007/10/17 23:20:49 tmclaugh Exp $
29 #include "namespace.h"
34 #include "un-namespace.h"
35 #include "nscachedcli.h"
38 #define NSS_CACHE_KEY_INITIAL_SIZE (256)
39 #define NSS_CACHE_KEY_SIZE_LIMIT (NSS_CACHE_KEY_INITIAL_SIZE << 4)
41 #define NSS_CACHE_BUFFER_INITIAL_SIZE (1024)
42 #define NSS_CACHE_BUFFER_SIZE_LIMIT (NSS_CACHE_BUFFER_INITIAL_SIZE << 8)
44 #define CACHED_SOCKET_PATH "/var/run/nscd"
47 __nss_cache_handler(void *retval __unused, void *mdata __unused,
54 __nss_common_cache_read(void *retval, void *mdata, va_list ap)
56 struct cached_connection_params params;
57 cached_connection connection;
60 size_t buffer_size, size;
62 nss_cache_info const *cache_info;
63 nss_cache_data *cache_data;
67 cache_data = (nss_cache_data *)mdata;
68 cache_info = cache_data->info;
70 memset(¶ms, 0, sizeof(struct cached_connection_params));
71 params.socket_path = CACHED_SOCKET_PATH;
73 cache_data->key = (char *)malloc(NSS_CACHE_KEY_INITIAL_SIZE);
74 memset(cache_data->key, 0, NSS_CACHE_KEY_INITIAL_SIZE);
75 cache_data->key_size = NSS_CACHE_KEY_INITIAL_SIZE;
79 size = cache_data->key_size;
80 res = cache_info->id_func(cache_data->key, &size, ap_new,
83 if (res == NS_RETURN) {
84 if (cache_data->key_size > NSS_CACHE_KEY_SIZE_LIMIT)
87 cache_data->key_size <<= 1;
88 cache_data->key = realloc(cache_data->key,
89 cache_data->key_size);
90 memset(cache_data->key, 0, cache_data->key_size);
93 } while (res == NS_RETURN);
95 if (res != NS_SUCCESS) {
96 free(cache_data->key);
97 cache_data->key = NULL;
98 cache_data->key_size = 0;
101 cache_data->key_size = size;
103 buffer_size = NSS_CACHE_BUFFER_INITIAL_SIZE;
104 buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE);
105 memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE);
108 connection = __open_cached_connection(¶ms);
109 if (connection == NULL) {
113 res = __cached_read(connection, cache_info->entry_name,
114 cache_data->key, cache_data->key_size, buffer,
116 __close_cached_connection(connection);
117 if (res == -2 && buffer_size < NSS_CACHE_BUFFER_SIZE_LIMIT) {
118 buffer = (char *)realloc(buffer, buffer_size);
119 memset(buffer, 0, buffer_size);
124 if (buffer_size == 0) {
126 free(cache_data->key);
127 cache_data->key = NULL;
128 cache_data->key_size = 0;
133 res = cache_info->unmarshal_func(buffer, buffer_size, retval,
134 ap_new, cache_info->mdata);
137 if (res != NS_SUCCESS) {
139 free(cache_data->key);
140 cache_data->key = NULL;
141 cache_data->key_size = 0;
148 free(cache_data->key);
149 cache_data->key = NULL;
150 cache_data->key_size = 0;
154 return (res == 0 ? NS_SUCCESS : NS_NOTFOUND);
158 __nss_common_cache_write(void *retval, void *mdata, va_list ap)
160 struct cached_connection_params params;
161 cached_connection connection;
166 nss_cache_info const *cache_info;
167 nss_cache_data *cache_data;
171 cache_data = (nss_cache_data *)mdata;
172 cache_info = cache_data->info;
174 if (cache_data->key == NULL)
177 memset(¶ms, 0, sizeof(struct cached_connection_params));
178 params.socket_path = CACHED_SOCKET_PATH;
180 connection = __open_cached_connection(¶ms);
181 if (connection == NULL) {
182 free(cache_data->key);
186 buffer_size = NSS_CACHE_BUFFER_INITIAL_SIZE;
187 buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE);
188 memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE);
195 res = cache_info->marshal_func(buffer, &size, retval, ap_new,
199 if (res == NS_RETURN) {
200 if (buffer_size > NSS_CACHE_BUFFER_SIZE_LIMIT)
204 buffer = (char *)realloc(buffer, buffer_size);
205 memset(buffer, 0, buffer_size);
207 } while (res == NS_RETURN);
209 if (res != NS_SUCCESS) {
210 __close_cached_connection(connection);
211 free(cache_data->key);
216 res = __cached_write(connection, cache_info->entry_name,
217 cache_data->key, cache_data->key_size, buffer, buffer_size);
218 __close_cached_connection(connection);
220 free(cache_data->key);
223 return (res == 0 ? NS_SUCCESS : NS_UNAVAIL);
227 __nss_common_cache_write_negative(void *mdata)
229 struct cached_connection_params params;
230 cached_connection connection;
233 nss_cache_info const *cache_info;
234 nss_cache_data *cache_data;
236 cache_data = (nss_cache_data *)mdata;
237 cache_info = cache_data->info;
239 if (cache_data->key == NULL)
242 memset(¶ms, 0, sizeof(struct cached_connection_params));
243 params.socket_path = CACHED_SOCKET_PATH;
245 connection = __open_cached_connection(¶ms);
246 if (connection == NULL) {
247 free(cache_data->key);
251 res = __cached_write(connection, cache_info->entry_name,
252 cache_data->key, cache_data->key_size, NULL, 0);
253 __close_cached_connection(connection);
255 free(cache_data->key);
256 return (res == 0 ? NS_SUCCESS : NS_UNAVAIL);
260 __nss_mp_cache_read(void *retval, void *mdata, va_list ap)
262 struct cached_connection_params params;
263 cached_mp_read_session rs;
268 nss_cache_info const *cache_info;
269 nss_cache_data *cache_data;
273 cache_data = (nss_cache_data *)mdata;
274 cache_info = cache_data->info;
276 if (cache_info->get_mp_ws_func() != INVALID_CACHED_MP_WRITE_SESSION)
279 rs = cache_info->get_mp_rs_func();
280 if (rs == INVALID_CACHED_MP_READ_SESSION) {
281 memset(¶ms, 0, sizeof(struct cached_connection_params));
282 params.socket_path = CACHED_SOCKET_PATH;
284 rs = __open_cached_mp_read_session(¶ms,
285 cache_info->entry_name);
286 if (rs == INVALID_CACHED_MP_READ_SESSION)
289 cache_info->set_mp_rs_func(rs);
292 buffer_size = NSS_CACHE_BUFFER_INITIAL_SIZE;
293 buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE);
294 memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE);
297 res = __cached_mp_read(rs, buffer, &buffer_size);
298 if (res == -2 && buffer_size < NSS_CACHE_BUFFER_SIZE_LIMIT) {
299 buffer = (char *)realloc(buffer, buffer_size);
300 memset(buffer, 0, buffer_size);
306 res = cache_info->unmarshal_func(buffer, buffer_size, retval,
307 ap_new, cache_info->mdata);
310 if (res != NS_SUCCESS) {
317 __close_cached_mp_read_session(rs);
318 rs = INVALID_CACHED_MP_READ_SESSION;
319 cache_info->set_mp_rs_func(rs);
320 return (res == -1 ? NS_RETURN : NS_UNAVAIL);
324 return (res == 0 ? NS_SUCCESS : NS_NOTFOUND);
328 __nss_mp_cache_write(void *retval, void *mdata, va_list ap)
330 struct cached_connection_params params;
331 cached_mp_write_session ws;
336 nss_cache_info const *cache_info;
337 nss_cache_data *cache_data;
341 cache_data = (nss_cache_data *)mdata;
342 cache_info = cache_data->info;
344 ws = cache_info->get_mp_ws_func();
345 if (ws == INVALID_CACHED_MP_WRITE_SESSION) {
346 memset(¶ms, 0, sizeof(struct cached_connection_params));
347 params.socket_path = CACHED_SOCKET_PATH;
349 ws = __open_cached_mp_write_session(¶ms,
350 cache_info->entry_name);
351 if (ws == INVALID_CACHED_MP_WRITE_SESSION)
354 cache_info->set_mp_ws_func(ws);
357 buffer_size = NSS_CACHE_BUFFER_INITIAL_SIZE;
358 buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE);
359 memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE);
366 res = cache_info->marshal_func(buffer, &size, retval, ap_new,
370 if (res == NS_RETURN) {
371 if (buffer_size > NSS_CACHE_BUFFER_SIZE_LIMIT)
375 buffer = (char *)realloc(buffer, buffer_size);
376 memset(buffer, 0, buffer_size);
378 } while (res == NS_RETURN);
380 if (res != NS_SUCCESS) {
385 res = __cached_mp_write(ws, buffer, buffer_size);
388 return (res == 0 ? NS_SUCCESS : NS_UNAVAIL);
392 __nss_mp_cache_write_submit(void *retval __unused, void *mdata,
395 cached_mp_write_session ws;
397 nss_cache_info const *cache_info;
398 nss_cache_data *cache_data;
400 cache_data = (nss_cache_data *)mdata;
401 cache_info = cache_data->info;
403 ws = cache_info->get_mp_ws_func();
404 if (ws != INVALID_CACHED_MP_WRITE_SESSION) {
405 __close_cached_mp_write_session(ws);
406 ws = INVALID_CACHED_MP_WRITE_SESSION;
407 cache_info->set_mp_ws_func(ws);
413 __nss_mp_cache_end(void *retval __unused, void *mdata, va_list ap __unused)
415 cached_mp_write_session ws;
416 cached_mp_read_session rs;
418 nss_cache_info const *cache_info;
419 nss_cache_data *cache_data;
421 cache_data = (nss_cache_data *)mdata;
422 cache_info = cache_data->info;
424 ws = cache_info->get_mp_ws_func();
425 if (ws != INVALID_CACHED_MP_WRITE_SESSION) {
426 __abandon_cached_mp_write_session(ws);
427 ws = INVALID_CACHED_MP_WRITE_SESSION;
428 cache_info->set_mp_ws_func(ws);
431 rs = cache_info->get_mp_rs_func();
432 if (rs != INVALID_CACHED_MP_READ_SESSION) {
433 __close_cached_mp_read_session(rs);
434 rs = INVALID_CACHED_MP_READ_SESSION;
435 cache_info->set_mp_rs_func(rs);