usr.sbin/nscd/protocol.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  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <assert.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include "debug.h"
  36 #include "log.h"
  37 #include "protocol.h"
  38
  39 /*
  40  * Initializes the comm_element with any given type of data
  41  */
  42 void
  43 init_comm_element(struct comm_element *element, enum comm_element_t type)
  44 {
  45
  46         TRACE_IN(init_comm_element);
  47         memset(element, 0, sizeof(struct comm_element));
  48
  49         switch (type) {
  50         case CET_WRITE_REQUEST:
  51                 init_cache_write_request(&element->c_write_request);
  52                 break;
  53         case CET_WRITE_RESPONSE:
  54                 init_cache_write_response(&element->c_write_response);
  55                 break;
  56         case CET_READ_REQUEST:
  57                 init_cache_read_request(&element->c_read_request);
  58                 break;
  59         case CET_READ_RESPONSE:
  60                 init_cache_read_response(&element->c_read_response);
  61                 break;
  62         case CET_TRANSFORM_REQUEST:
  63                 init_cache_transform_request(&element->c_transform_request);
  64                 break;
  65         case CET_TRANSFORM_RESPONSE:
  66                 init_cache_transform_response(&element->c_transform_response);
  67                 break;
  68         case CET_MP_WRITE_SESSION_REQUEST:
  69                 init_cache_mp_write_session_request(&element->c_mp_ws_request);
  70                 break;
  71         case CET_MP_WRITE_SESSION_RESPONSE:
  72                 init_cache_mp_write_session_response(&element->c_mp_ws_response);
  73                 break;
  74         case CET_MP_WRITE_SESSION_WRITE_REQUEST:
  75                 init_cache_mp_write_session_write_request(
  76                         &element->c_mp_ws_write_request);
  77                 break;
  78         case CET_MP_WRITE_SESSION_WRITE_RESPONSE:
  79                 init_cache_mp_write_session_write_response(
  80                         &element->c_mp_ws_write_response);
  81                 break;
  82         case CET_MP_READ_SESSION_REQUEST:
  83                 init_cache_mp_read_session_request(&element->c_mp_rs_request);
  84                 break;
  85         case CET_MP_READ_SESSION_RESPONSE:
  86                 init_cache_mp_read_session_response(&element->c_mp_rs_response);
  87                 break;
  88         case CET_MP_READ_SESSION_READ_RESPONSE:
  89                 init_cache_mp_read_session_read_response(
  90                         &element->c_mp_rs_read_response);
  91                 break;
  92         case CET_UNDEFINED:
  93                 break;
  94         default:
  95                 LOG_ERR_2("init_comm_element", "invalid communication element");
  96                 TRACE_OUT(init_comm_element);
  97         return;
  98         }
  99
 100         element->type = type;
 101         TRACE_OUT(init_comm_element);
 102 }
 103
 104 void
 105 finalize_comm_element(struct comm_element *element)
 106 {
 107
 108         TRACE_IN(finalize_comm_element);
 109         switch (element->type) {
 110         case CET_WRITE_REQUEST:
 111                 finalize_cache_write_request(&element->c_write_request);
 112                 break;
 113         case CET_WRITE_RESPONSE:
 114                 finalize_cache_write_response(&element->c_write_response);
 115                 break;
 116         case CET_READ_REQUEST:
 117                 finalize_cache_read_request(&element->c_read_request);
 118                 break;
 119         case CET_READ_RESPONSE:
 120                 finalize_cache_read_response(&element->c_read_response);
 121                 break;
 122         case CET_TRANSFORM_REQUEST:
 123                 finalize_cache_transform_request(&element->c_transform_request);
 124                 break;
 125         case CET_TRANSFORM_RESPONSE:
 126                 finalize_cache_transform_response(
 127                         &element->c_transform_response);
 128                 break;
 129         case CET_MP_WRITE_SESSION_REQUEST:
 130                 finalize_cache_mp_write_session_request(
 131                         &element->c_mp_ws_request);
 132                 break;
 133         case CET_MP_WRITE_SESSION_RESPONSE:
 134                 finalize_cache_mp_write_session_response(
 135                         &element->c_mp_ws_response);
 136                 break;
 137         case CET_MP_WRITE_SESSION_WRITE_REQUEST:
 138                 finalize_cache_mp_write_session_write_request(
 139                         &element->c_mp_ws_write_request);
 140                 break;
 141         case CET_MP_WRITE_SESSION_WRITE_RESPONSE:
 142                 finalize_cache_mp_write_session_write_response(
 143                         &element->c_mp_ws_write_response);
 144                 break;
 145         case CET_MP_READ_SESSION_REQUEST:
 146                 finalize_cache_mp_read_session_request(
 147                         &element->c_mp_rs_request);
 148                 break;
 149         case CET_MP_READ_SESSION_RESPONSE:
 150                 finalize_cache_mp_read_session_response(
 151                         &element->c_mp_rs_response);
 152                 break;
 153         case CET_MP_READ_SESSION_READ_RESPONSE:
 154                 finalize_cache_mp_read_session_read_response(
 155                         &element->c_mp_rs_read_response);
 156                 break;
 157         case CET_UNDEFINED:
 158                 break;
 159         default:
 160         break;
 161         }
 162
 163         element->type = CET_UNDEFINED;
 164         TRACE_OUT(finalize_comm_element);
 165 }
 166
 167 void
 168 init_cache_write_request(struct cache_write_request *write_request)
 169 {
 170
 171         TRACE_IN(init_cache_write_request);
 172         memset(write_request, 0, sizeof(struct cache_write_request));
 173         TRACE_OUT(init_cache_write_request);
 174 }
 175
 176 void
 177 finalize_cache_write_request(struct cache_write_request *write_request)
 178 {
 179
 180         TRACE_IN(finalize_cache_write_request);
 181         free(write_request->entry);
 182         free(write_request->cache_key);
 183         free(write_request->data);
 184         TRACE_OUT(finalize_cache_write_request);
 185 }
 186
 187 struct cache_write_request *
 188 get_cache_write_request(struct comm_element *element)
 189 {
 190
 191         TRACE_IN(get_cache_write_request);
 192         assert(element->type == CET_WRITE_REQUEST);
 193         TRACE_OUT(get_cache_write_request);
 194         return (&element->c_write_request);
 195 }
 196
 197 void
 198 init_cache_write_response(struct cache_write_response *write_response)
 199 {
 200
 201         TRACE_IN(init_cache_write_response);
 202         memset(write_response, 0, sizeof(struct cache_write_response));
 203         TRACE_OUT(init_cache_write_response);
 204 }
 205
 206 void
 207 finalize_cache_write_response(struct cache_write_response *write_response)
 208 {
 209
 210         TRACE_IN(finalize_cache_write_response);
 211         TRACE_OUT(finalize_cache_write_response);
 212 }
 213
 214 struct cache_write_response *
 215 get_cache_write_response(struct comm_element *element)
 216 {
 217
 218         TRACE_IN(get_cache_write_response);
 219         assert(element->type == CET_WRITE_RESPONSE);
 220         TRACE_OUT(get_cache_write_response);
 221         return (&element->c_write_response);
 222 }
 223
 224 void
 225 init_cache_read_request(struct cache_read_request *read_request)
 226 {
 227
 228         TRACE_IN(init_cache_read_request);
 229         memset(read_request, 0, sizeof(struct cache_read_request));
 230         TRACE_OUT(init_cache_read_request);
 231 }
 232
 233 void
 234 finalize_cache_read_request(struct cache_read_request *read_request)
 235 {
 236
 237         TRACE_IN(finalize_cache_read_request);
 238         free(read_request->entry);
 239         free(read_request->cache_key);
 240         TRACE_OUT(finalize_cache_read_request);
 241 }
 242
 243 struct cache_read_request *
 244 get_cache_read_request(struct comm_element *element)
 245 {
 246
 247         TRACE_IN(get_cache_read_request);
 248         assert(element->type == CET_READ_REQUEST);
 249         TRACE_OUT(get_cache_read_request);
 250         return (&element->c_read_request);
 251 }
 252
 253 void
 254 init_cache_read_response(struct cache_read_response *read_response)
 255 {
 256
 257         TRACE_IN(init_cache_read_response);
 258         memset(read_response, 0, sizeof(struct cache_read_response));
 259         TRACE_OUT(init_cache_read_response);
 260 }
 261
 262 void
 263 finalize_cache_read_response(struct cache_read_response *read_response)
 264 {
 265
 266         TRACE_IN(finalize_cache_read_response);
 267         free(read_response->data);
 268         TRACE_OUT(finalize_cache_read_response);
 269 }
 270
 271 struct cache_read_response *
 272 get_cache_read_response(struct comm_element *element)
 273 {
 274
 275         TRACE_IN(get_cache_read_response);
 276         assert(element->type == CET_READ_RESPONSE);
 277         TRACE_OUT(get_cache_read_response);
 278         return (&element->c_read_response);
 279 }
 280
 281 void
 282 init_cache_transform_request(struct cache_transform_request *transform_request)
 283 {
 284
 285         TRACE_IN(init_cache_transform_request);
 286         memset(transform_request, 0, sizeof(struct cache_transform_request));
 287         TRACE_OUT(init_cache_transform_request);
 288 }
 289
 290 void
 291 finalize_cache_transform_request(
 292         struct cache_transform_request *transform_request)
 293 {
 294
 295         TRACE_IN(finalize_cache_transform_request);
 296         free(transform_request->entry);
 297         TRACE_OUT(finalize_cache_transform_request);
 298 }
 299
 300 struct cache_transform_request *
 301 get_cache_transform_request(struct comm_element *element)
 302 {
 303
 304         TRACE_IN(get_cache_transform_request);
 305         assert(element->type == CET_TRANSFORM_REQUEST);
 306         TRACE_OUT(get_cache_transform_request);
 307         return (&element->c_transform_request);
 308 }
 309
 310 void
 311 init_cache_transform_response(
 312         struct cache_transform_response *transform_response)
 313 {
 314
 315         TRACE_IN(init_cache_transform_request);
 316         memset(transform_response, 0, sizeof(struct cache_transform_response));
 317         TRACE_OUT(init_cache_transform_request);
 318 }
 319
 320 void
 321 finalize_cache_transform_response(
 322         struct cache_transform_response *transform_response)
 323 {
 324
 325         TRACE_IN(finalize_cache_transform_response);
 326         TRACE_OUT(finalize_cache_transform_response);
 327 }
 328
 329 struct cache_transform_response *
 330 get_cache_transform_response(struct comm_element *element)
 331 {
 332
 333         TRACE_IN(get_cache_transform_response);
 334         assert(element->type == CET_TRANSFORM_RESPONSE);
 335         TRACE_OUT(get_cache_transform_response);
 336         return (&element->c_transform_response);
 337 }
 338
 339
 340 void
 341 init_cache_mp_write_session_request(
 342         struct cache_mp_write_session_request *mp_ws_request)
 343 {
 344
 345         TRACE_IN(init_cache_mp_write_session_request);
 346         memset(mp_ws_request, 0,
 347                 sizeof(struct cache_mp_write_session_request));
 348         TRACE_OUT(init_cache_mp_write_session_request);
 349 }
 350
 351 void
 352 finalize_cache_mp_write_session_request(
 353         struct cache_mp_write_session_request *mp_ws_request)
 354 {
 355
 356         TRACE_IN(finalize_cache_mp_write_session_request);
 357         free(mp_ws_request->entry);
 358         TRACE_OUT(finalize_cache_mp_write_session_request);
 359 }
 360
 361 struct cache_mp_write_session_request *
 362 get_cache_mp_write_session_request(struct comm_element *element)
 363 {
 364
 365         TRACE_IN(get_cache_mp_write_session_request);
 366         assert(element->type == CET_MP_WRITE_SESSION_REQUEST);
 367         TRACE_OUT(get_cache_mp_write_session_request);
 368         return (&element->c_mp_ws_request);
 369 }
 370
 371 void
 372 init_cache_mp_write_session_response(
 373         struct cache_mp_write_session_response *mp_ws_response)
 374 {
 375
 376         TRACE_IN(init_cache_mp_write_session_response);
 377         memset(mp_ws_response, 0,
 378                 sizeof(struct cache_mp_write_session_response));
 379         TRACE_OUT(init_cache_mp_write_session_response);
 380 }
 381
 382 void
 383 finalize_cache_mp_write_session_response(
 384         struct cache_mp_write_session_response *mp_ws_response)
 385 {
 386
 387         TRACE_IN(finalize_cache_mp_write_session_response);
 388         TRACE_OUT(finalize_cache_mp_write_session_response);
 389 }
 390
 391 struct cache_mp_write_session_response *
 392 get_cache_mp_write_session_response(struct comm_element *element)
 393 {
 394
 395         TRACE_IN(get_cache_mp_write_session_response);
 396         assert(element->type == CET_MP_WRITE_SESSION_RESPONSE);
 397         TRACE_OUT(get_cache_mp_write_session_response);
 398         return (&element->c_mp_ws_response);
 399 }
 400
 401 void
 402 init_cache_mp_write_session_write_request(
 403         struct cache_mp_write_session_write_request *mp_ws_write_request)
 404 {
 405
 406         TRACE_IN(init_cache_mp_write_session_write_request);
 407         memset(mp_ws_write_request, 0,
 408                 sizeof(struct cache_mp_write_session_write_request));
 409         TRACE_OUT(init_cache_mp_write_session_write_response);
 410 }
 411
 412 void
 413 finalize_cache_mp_write_session_write_request(
 414         struct cache_mp_write_session_write_request *mp_ws_write_request)
 415 {
 416
 417         TRACE_IN(finalize_cache_mp_write_session_write_request);
 418         free(mp_ws_write_request->data);
 419         TRACE_OUT(finalize_cache_mp_write_session_write_request);
 420 }
 421
 422 struct cache_mp_write_session_write_request *
 423 get_cache_mp_write_session_write_request(struct comm_element *element)
 424 {
 425
 426         TRACE_IN(get_cache_mp_write_session_write_request);
 427         assert(element->type == CET_MP_WRITE_SESSION_WRITE_REQUEST);
 428         TRACE_OUT(get_cache_mp_write_session_write_request);
 429         return (&element->c_mp_ws_write_request);
 430 }
 431
 432 void
 433 init_cache_mp_write_session_write_response(
 434         struct cache_mp_write_session_write_response *mp_ws_write_response)
 435 {
 436
 437         TRACE_IN(init_cache_mp_write_session_write_response);
 438         memset(mp_ws_write_response, 0,
 439                 sizeof(struct cache_mp_write_session_write_response));
 440         TRACE_OUT(init_cache_mp_write_session_write_response);
 441 }
 442
 443 void
 444 finalize_cache_mp_write_session_write_response(
 445         struct cache_mp_write_session_write_response *mp_ws_write_response)
 446 {
 447
 448         TRACE_IN(finalize_cache_mp_write_session_write_response);
 449         TRACE_OUT(finalize_cache_mp_write_session_write_response);
 450 }
 451
 452 struct cache_mp_write_session_write_response *
 453 get_cache_mp_write_session_write_response(struct comm_element *element)
 454 {
 455
 456         TRACE_IN(get_cache_mp_write_session_write_response);
 457         assert(element->type == CET_MP_WRITE_SESSION_WRITE_RESPONSE);
 458         TRACE_OUT(get_cache_mp_write_session_write_response);
 459         return (&element->c_mp_ws_write_response);
 460 }
 461
 462 void
 463 init_cache_mp_read_session_request(
 464         struct cache_mp_read_session_request *mp_rs_request)
 465 {
 466
 467         TRACE_IN(init_cache_mp_read_session_request);
 468         memset(mp_rs_request, 0, sizeof(struct cache_mp_read_session_request));
 469         TRACE_OUT(init_cache_mp_read_session_request);
 470 }
 471
 472 void
 473 finalize_cache_mp_read_session_request(
 474         struct cache_mp_read_session_request *mp_rs_request)
 475 {
 476
 477         TRACE_IN(finalize_cache_mp_read_session_request);
 478         free(mp_rs_request->entry);
 479         TRACE_OUT(finalize_cache_mp_read_session_request);
 480 }
 481
 482 struct cache_mp_read_session_request *
 483 get_cache_mp_read_session_request(struct comm_element *element)
 484 {
 485
 486         TRACE_IN(get_cache_mp_read_session_request);
 487         assert(element->type == CET_MP_READ_SESSION_REQUEST);
 488         TRACE_OUT(get_cache_mp_read_session_request);
 489         return (&element->c_mp_rs_request);
 490 }
 491
 492 void
 493 init_cache_mp_read_session_response(
 494         struct cache_mp_read_session_response *mp_rs_response)
 495 {
 496
 497         TRACE_IN(init_cache_mp_read_session_response);
 498         memset(mp_rs_response, 0,
 499                 sizeof(struct cache_mp_read_session_response));
 500         TRACE_OUT(init_cache_mp_read_session_response);
 501 }
 502
 503 void
 504 finalize_cache_mp_read_session_response(
 505         struct cache_mp_read_session_response *mp_rs_response)
 506 {
 507
 508         TRACE_IN(finalize_cache_mp_read_session_response);
 509         TRACE_OUT(finalize_cache_mp_read_session_response);
 510 }
 511
 512 struct cache_mp_read_session_response *
 513 get_cache_mp_read_session_response(struct comm_element *element)
 514 {
 515
 516         TRACE_IN(get_cache_mp_read_session_response);
 517         assert(element->type == CET_MP_READ_SESSION_RESPONSE);
 518         TRACE_OUT(get_cache_mp_read_session_response);
 519         return (&element->c_mp_rs_response);
 520 }
 521
 522 void
 523 init_cache_mp_read_session_read_response(
 524         struct cache_mp_read_session_read_response *mp_ws_read_response)
 525 {
 526
 527         TRACE_IN(init_cache_mp_read_session_read_response);
 528         memset(mp_ws_read_response, 0,
 529                 sizeof(struct cache_mp_read_session_read_response));
 530         TRACE_OUT(init_cache_mp_read_session_read_response);
 531 }
 532
 533 void
 534 finalize_cache_mp_read_session_read_response(
 535         struct cache_mp_read_session_read_response *mp_rs_read_response)
 536 {
 537
 538         TRACE_IN(finalize_cache_mp_read_session_read_response);
 539         free(mp_rs_read_response->data);
 540         TRACE_OUT(finalize_cache_mp_read_session_read_response);
 541 }
 542
 543 struct cache_mp_read_session_read_response *
 544 get_cache_mp_read_session_read_response(struct comm_element *element)
 545 {
 546
 547         TRACE_IN(get_cache_mp_read_session_read_response);
 548         assert(element->type == CET_MP_READ_SESSION_READ_RESPONSE);
 549         TRACE_OUT(get_cache_mp_read_session_read_response);
 550         return (&element->c_mp_rs_read_response);
 551 }