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