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