1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 */ 29 30 #include <sys/cdefs.h> 31 #include "namespace.h" 32 #define _NS_PRIVATE 33 #include <nsswitch.h> 34 #include <stdlib.h> 35 #include <string.h> 36 #include "un-namespace.h" 37 #include "nscachedcli.h" 38 #include "nscache.h" 39 40 #define NSS_CACHE_KEY_INITIAL_SIZE (256) 41 #define NSS_CACHE_KEY_SIZE_LIMIT (NSS_CACHE_KEY_INITIAL_SIZE << 4) 42 43 #define NSS_CACHE_BUFFER_INITIAL_SIZE (1024) 44 #define NSS_CACHE_BUFFER_SIZE_LIMIT (NSS_CACHE_BUFFER_INITIAL_SIZE << 8) 45 46 #define CACHED_SOCKET_PATH "/var/run/nscd" 47 48 int 49 __nss_cache_handler(void *retval, void *mdata, va_list ap) 50 { 51 return (NS_UNAVAIL); 52 } 53 54 int 55 __nss_common_cache_read(void *retval, void *mdata, va_list ap) 56 { 57 struct cached_connection_params params; 58 cached_connection connection; 59 60 char *buffer; 61 size_t buffer_size, size; 62 63 nss_cache_info const *cache_info; 64 nss_cache_data *cache_data; 65 va_list ap_new; 66 int res; 67 68 cache_data = (nss_cache_data *)mdata; 69 cache_info = cache_data->info; 70 71 memset(¶ms, 0, sizeof(struct cached_connection_params)); 72 params.socket_path = CACHED_SOCKET_PATH; 73 74 cache_data->key = (char *)malloc(NSS_CACHE_KEY_INITIAL_SIZE); 75 memset(cache_data->key, 0, NSS_CACHE_KEY_INITIAL_SIZE); 76 cache_data->key_size = NSS_CACHE_KEY_INITIAL_SIZE; 77 va_copy(ap_new, ap); 78 79 do { 80 size = cache_data->key_size; 81 res = cache_info->id_func(cache_data->key, &size, ap_new, 82 cache_info->mdata); 83 va_end(ap_new); 84 if (res == NS_RETURN) { 85 if (cache_data->key_size > NSS_CACHE_KEY_SIZE_LIMIT) 86 break; 87 88 cache_data->key_size <<= 1; 89 cache_data->key = realloc(cache_data->key, 90 cache_data->key_size); 91 memset(cache_data->key, 0, cache_data->key_size); 92 va_copy(ap_new, ap); 93 } 94 } while (res == NS_RETURN); 95 96 if (res != NS_SUCCESS) { 97 free(cache_data->key); 98 cache_data->key = NULL; 99 cache_data->key_size = 0; 100 return (res); 101 } else 102 cache_data->key_size = size; 103 104 buffer_size = NSS_CACHE_BUFFER_INITIAL_SIZE; 105 buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE); 106 memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE); 107 108 do { 109 connection = __open_cached_connection(¶ms); 110 if (connection == NULL) { 111 res = -1; 112 break; 113 } 114 res = __cached_read(connection, cache_info->entry_name, 115 cache_data->key, cache_data->key_size, buffer, 116 &buffer_size); 117 __close_cached_connection(connection); 118 if (res == -2 && buffer_size < NSS_CACHE_BUFFER_SIZE_LIMIT) { 119 buffer = (char *)realloc(buffer, buffer_size); 120 memset(buffer, 0, buffer_size); 121 } 122 } while (res == -2); 123 124 if (res == 0) { 125 if (buffer_size == 0) { 126 free(buffer); 127 free(cache_data->key); 128 cache_data->key = NULL; 129 cache_data->key_size = 0; 130 return (NS_RETURN); 131 } 132 133 va_copy(ap_new, ap); 134 res = cache_info->unmarshal_func(buffer, buffer_size, retval, 135 ap_new, cache_info->mdata); 136 va_end(ap_new); 137 138 if (res != NS_SUCCESS) { 139 free(buffer); 140 free(cache_data->key); 141 cache_data->key = NULL; 142 cache_data->key_size = 0; 143 return (res); 144 } else 145 res = 0; 146 } 147 148 if (res == 0) { 149 free(cache_data->key); 150 cache_data->key = NULL; 151 cache_data->key_size = 0; 152 } 153 154 free(buffer); 155 return (res == 0 ? NS_SUCCESS : NS_NOTFOUND); 156 } 157 158 int 159 __nss_common_cache_write(void *retval, void *mdata, va_list ap) 160 { 161 struct cached_connection_params params; 162 cached_connection connection; 163 164 char *buffer; 165 size_t buffer_size; 166 167 nss_cache_info const *cache_info; 168 nss_cache_data *cache_data; 169 va_list ap_new; 170 int res; 171 172 cache_data = (nss_cache_data *)mdata; 173 cache_info = cache_data->info; 174 175 if (cache_data->key == NULL) 176 return (NS_UNAVAIL); 177 178 memset(¶ms, 0, sizeof(struct cached_connection_params)); 179 params.socket_path = CACHED_SOCKET_PATH; 180 181 connection = __open_cached_connection(¶ms); 182 if (connection == NULL) { 183 free(cache_data->key); 184 return (NS_UNAVAIL); 185 } 186 187 buffer_size = NSS_CACHE_BUFFER_INITIAL_SIZE; 188 buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE); 189 memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE); 190 191 do { 192 size_t size; 193 194 size = buffer_size; 195 va_copy(ap_new, ap); 196 res = cache_info->marshal_func(buffer, &size, retval, ap_new, 197 cache_info->mdata); 198 va_end(ap_new); 199 200 if (res == NS_RETURN) { 201 if (buffer_size > NSS_CACHE_BUFFER_SIZE_LIMIT) 202 break; 203 204 buffer_size <<= 1; 205 buffer = (char *)realloc(buffer, buffer_size); 206 memset(buffer, 0, buffer_size); 207 } 208 } while (res == NS_RETURN); 209 210 if (res != NS_SUCCESS) { 211 __close_cached_connection(connection); 212 free(cache_data->key); 213 free(buffer); 214 return (res); 215 } 216 217 res = __cached_write(connection, cache_info->entry_name, 218 cache_data->key, cache_data->key_size, buffer, buffer_size); 219 __close_cached_connection(connection); 220 221 free(cache_data->key); 222 free(buffer); 223 224 return (res == 0 ? NS_SUCCESS : NS_UNAVAIL); 225 } 226 227 int 228 __nss_common_cache_write_negative(void *mdata) 229 { 230 struct cached_connection_params params; 231 cached_connection connection; 232 int res; 233 234 nss_cache_info const *cache_info; 235 nss_cache_data *cache_data; 236 237 cache_data = (nss_cache_data *)mdata; 238 cache_info = cache_data->info; 239 240 if (cache_data->key == NULL) 241 return (NS_UNAVAIL); 242 243 memset(¶ms, 0, sizeof(struct cached_connection_params)); 244 params.socket_path = CACHED_SOCKET_PATH; 245 246 connection = __open_cached_connection(¶ms); 247 if (connection == NULL) { 248 free(cache_data->key); 249 return (NS_UNAVAIL); 250 } 251 252 res = __cached_write(connection, cache_info->entry_name, 253 cache_data->key, cache_data->key_size, NULL, 0); 254 __close_cached_connection(connection); 255 256 free(cache_data->key); 257 return (res == 0 ? NS_SUCCESS : NS_UNAVAIL); 258 } 259 260 int 261 __nss_mp_cache_read(void *retval, void *mdata, va_list ap) 262 { 263 struct cached_connection_params params; 264 cached_mp_read_session rs; 265 266 char *buffer; 267 size_t buffer_size; 268 269 nss_cache_info const *cache_info; 270 nss_cache_data *cache_data; 271 va_list ap_new; 272 int res; 273 274 cache_data = (nss_cache_data *)mdata; 275 cache_info = cache_data->info; 276 277 if (cache_info->get_mp_ws_func() != INVALID_CACHED_MP_WRITE_SESSION) 278 return (NS_UNAVAIL); 279 280 rs = cache_info->get_mp_rs_func(); 281 if (rs == INVALID_CACHED_MP_READ_SESSION) { 282 memset(¶ms, 0, sizeof(struct cached_connection_params)); 283 params.socket_path = CACHED_SOCKET_PATH; 284 285 rs = __open_cached_mp_read_session(¶ms, 286 cache_info->entry_name); 287 if (rs == INVALID_CACHED_MP_READ_SESSION) 288 return (NS_UNAVAIL); 289 290 cache_info->set_mp_rs_func(rs); 291 } 292 293 buffer_size = NSS_CACHE_BUFFER_INITIAL_SIZE; 294 buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE); 295 memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE); 296 297 do { 298 res = __cached_mp_read(rs, buffer, &buffer_size); 299 if (res == -2 && buffer_size < NSS_CACHE_BUFFER_SIZE_LIMIT) { 300 buffer = (char *)realloc(buffer, buffer_size); 301 memset(buffer, 0, buffer_size); 302 } 303 } while (res == -2); 304 305 if (res == 0) { 306 va_copy(ap_new, ap); 307 res = cache_info->unmarshal_func(buffer, buffer_size, retval, 308 ap_new, cache_info->mdata); 309 va_end(ap_new); 310 311 if (res != NS_SUCCESS) { 312 free(buffer); 313 return (res); 314 } else 315 res = 0; 316 } else { 317 free(buffer); 318 __close_cached_mp_read_session(rs); 319 rs = INVALID_CACHED_MP_READ_SESSION; 320 cache_info->set_mp_rs_func(rs); 321 return (res == -1 ? NS_RETURN : NS_UNAVAIL); 322 } 323 324 free(buffer); 325 return (res == 0 ? NS_SUCCESS : NS_NOTFOUND); 326 } 327 328 int 329 __nss_mp_cache_write(void *retval, void *mdata, va_list ap) 330 { 331 struct cached_connection_params params; 332 cached_mp_write_session ws; 333 334 char *buffer; 335 size_t buffer_size; 336 337 nss_cache_info const *cache_info; 338 nss_cache_data *cache_data; 339 va_list ap_new; 340 int res; 341 342 cache_data = (nss_cache_data *)mdata; 343 cache_info = cache_data->info; 344 345 ws = cache_info->get_mp_ws_func(); 346 if (ws == INVALID_CACHED_MP_WRITE_SESSION) { 347 memset(¶ms, 0, sizeof(struct cached_connection_params)); 348 params.socket_path = CACHED_SOCKET_PATH; 349 350 ws = __open_cached_mp_write_session(¶ms, 351 cache_info->entry_name); 352 if (ws == INVALID_CACHED_MP_WRITE_SESSION) 353 return (NS_UNAVAIL); 354 355 cache_info->set_mp_ws_func(ws); 356 } 357 358 buffer_size = NSS_CACHE_BUFFER_INITIAL_SIZE; 359 buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE); 360 memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE); 361 362 do { 363 size_t size; 364 365 size = buffer_size; 366 va_copy(ap_new, ap); 367 res = cache_info->marshal_func(buffer, &size, retval, ap_new, 368 cache_info->mdata); 369 va_end(ap_new); 370 371 if (res == NS_RETURN) { 372 if (buffer_size > NSS_CACHE_BUFFER_SIZE_LIMIT) 373 break; 374 375 buffer_size <<= 1; 376 buffer = (char *)realloc(buffer, buffer_size); 377 memset(buffer, 0, buffer_size); 378 } 379 } while (res == NS_RETURN); 380 381 if (res != NS_SUCCESS) { 382 free(buffer); 383 return (res); 384 } 385 386 res = __cached_mp_write(ws, buffer, buffer_size); 387 388 free(buffer); 389 return (res == 0 ? NS_SUCCESS : NS_UNAVAIL); 390 } 391 392 int 393 __nss_mp_cache_write_submit(void *retval, void *mdata, va_list ap) 394 { 395 cached_mp_write_session ws; 396 397 nss_cache_info const *cache_info; 398 nss_cache_data *cache_data; 399 400 cache_data = (nss_cache_data *)mdata; 401 cache_info = cache_data->info; 402 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); 408 } 409 return (NS_UNAVAIL); 410 } 411 412 int 413 __nss_mp_cache_end(void *retval, void *mdata, va_list ap) 414 { 415 cached_mp_write_session ws; 416 cached_mp_read_session rs; 417 418 nss_cache_info const *cache_info; 419 nss_cache_data *cache_data; 420 421 cache_data = (nss_cache_data *)mdata; 422 cache_info = cache_data->info; 423 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); 429 } 430 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); 436 } 437 438 return (NS_UNAVAIL); 439 } 440