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