lib/libc/net/nscache.c

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