2 * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
28 #include <sys/cdefs.h>
38 * Initializes the comm_element with any given type of data
41 init_comm_element(struct comm_element *element, enum comm_element_t type)
44 TRACE_IN(init_comm_element);
45 memset(element, 0, sizeof(struct comm_element));
48 case CET_WRITE_REQUEST:
49 init_cache_write_request(&element->c_write_request);
51 case CET_WRITE_RESPONSE:
52 init_cache_write_response(&element->c_write_response);
54 case CET_READ_REQUEST:
55 init_cache_read_request(&element->c_read_request);
57 case CET_READ_RESPONSE:
58 init_cache_read_response(&element->c_read_response);
60 case CET_TRANSFORM_REQUEST:
61 init_cache_transform_request(&element->c_transform_request);
63 case CET_TRANSFORM_RESPONSE:
64 init_cache_transform_response(&element->c_transform_response);
66 case CET_MP_WRITE_SESSION_REQUEST:
67 init_cache_mp_write_session_request(&element->c_mp_ws_request);
69 case CET_MP_WRITE_SESSION_RESPONSE:
70 init_cache_mp_write_session_response(&element->c_mp_ws_response);
72 case CET_MP_WRITE_SESSION_WRITE_REQUEST:
73 init_cache_mp_write_session_write_request(
74 &element->c_mp_ws_write_request);
76 case CET_MP_WRITE_SESSION_WRITE_RESPONSE:
77 init_cache_mp_write_session_write_response(
78 &element->c_mp_ws_write_response);
80 case CET_MP_READ_SESSION_REQUEST:
81 init_cache_mp_read_session_request(&element->c_mp_rs_request);
83 case CET_MP_READ_SESSION_RESPONSE:
84 init_cache_mp_read_session_response(&element->c_mp_rs_response);
86 case CET_MP_READ_SESSION_READ_RESPONSE:
87 init_cache_mp_read_session_read_response(
88 &element->c_mp_rs_read_response);
93 LOG_ERR_2("init_comm_element", "invalid communication element");
94 TRACE_OUT(init_comm_element);
99 TRACE_OUT(init_comm_element);
103 finalize_comm_element(struct comm_element *element)
106 TRACE_IN(finalize_comm_element);
107 switch (element->type) {
108 case CET_WRITE_REQUEST:
109 finalize_cache_write_request(&element->c_write_request);
111 case CET_WRITE_RESPONSE:
112 finalize_cache_write_response(&element->c_write_response);
114 case CET_READ_REQUEST:
115 finalize_cache_read_request(&element->c_read_request);
117 case CET_READ_RESPONSE:
118 finalize_cache_read_response(&element->c_read_response);
120 case CET_TRANSFORM_REQUEST:
121 finalize_cache_transform_request(&element->c_transform_request);
123 case CET_TRANSFORM_RESPONSE:
124 finalize_cache_transform_response(
125 &element->c_transform_response);
127 case CET_MP_WRITE_SESSION_REQUEST:
128 finalize_cache_mp_write_session_request(
129 &element->c_mp_ws_request);
131 case CET_MP_WRITE_SESSION_RESPONSE:
132 finalize_cache_mp_write_session_response(
133 &element->c_mp_ws_response);
135 case CET_MP_WRITE_SESSION_WRITE_REQUEST:
136 finalize_cache_mp_write_session_write_request(
137 &element->c_mp_ws_write_request);
139 case CET_MP_WRITE_SESSION_WRITE_RESPONSE:
140 finalize_cache_mp_write_session_write_response(
141 &element->c_mp_ws_write_response);
143 case CET_MP_READ_SESSION_REQUEST:
144 finalize_cache_mp_read_session_request(
145 &element->c_mp_rs_request);
147 case CET_MP_READ_SESSION_RESPONSE:
148 finalize_cache_mp_read_session_response(
149 &element->c_mp_rs_response);
151 case CET_MP_READ_SESSION_READ_RESPONSE:
152 finalize_cache_mp_read_session_read_response(
153 &element->c_mp_rs_read_response);
161 element->type = CET_UNDEFINED;
162 TRACE_OUT(finalize_comm_element);
166 init_cache_write_request(struct cache_write_request *write_request)
169 TRACE_IN(init_cache_write_request);
170 memset(write_request, 0, sizeof(struct cache_write_request));
171 TRACE_OUT(init_cache_write_request);
175 finalize_cache_write_request(struct cache_write_request *write_request)
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);
185 struct cache_write_request *
186 get_cache_write_request(struct comm_element *element)
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);
196 init_cache_write_response(struct cache_write_response *write_response)
199 TRACE_IN(init_cache_write_response);
200 memset(write_response, 0, sizeof(struct cache_write_response));
201 TRACE_OUT(init_cache_write_response);
205 finalize_cache_write_response(struct cache_write_response *write_response)
208 TRACE_IN(finalize_cache_write_response);
209 TRACE_OUT(finalize_cache_write_response);
212 struct cache_write_response *
213 get_cache_write_response(struct comm_element *element)
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);
223 init_cache_read_request(struct cache_read_request *read_request)
226 TRACE_IN(init_cache_read_request);
227 memset(read_request, 0, sizeof(struct cache_read_request));
228 TRACE_OUT(init_cache_read_request);
232 finalize_cache_read_request(struct cache_read_request *read_request)
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);
241 struct cache_read_request *
242 get_cache_read_request(struct comm_element *element)
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);
252 init_cache_read_response(struct cache_read_response *read_response)
255 TRACE_IN(init_cache_read_response);
256 memset(read_response, 0, sizeof(struct cache_read_response));
257 TRACE_OUT(init_cache_read_response);
261 finalize_cache_read_response(struct cache_read_response *read_response)
264 TRACE_IN(finalize_cache_read_response);
265 free(read_response->data);
266 TRACE_OUT(finalize_cache_read_response);
269 struct cache_read_response *
270 get_cache_read_response(struct comm_element *element)
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);
280 init_cache_transform_request(struct cache_transform_request *transform_request)
283 TRACE_IN(init_cache_transform_request);
284 memset(transform_request, 0, sizeof(struct cache_transform_request));
285 TRACE_OUT(init_cache_transform_request);
289 finalize_cache_transform_request(
290 struct cache_transform_request *transform_request)
293 TRACE_IN(finalize_cache_transform_request);
294 free(transform_request->entry);
295 TRACE_OUT(finalize_cache_transform_request);
298 struct cache_transform_request *
299 get_cache_transform_request(struct comm_element *element)
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);
309 init_cache_transform_response(
310 struct cache_transform_response *transform_response)
313 TRACE_IN(init_cache_transform_request);
314 memset(transform_response, 0, sizeof(struct cache_transform_response));
315 TRACE_OUT(init_cache_transform_request);
319 finalize_cache_transform_response(
320 struct cache_transform_response *transform_response)
323 TRACE_IN(finalize_cache_transform_response);
324 TRACE_OUT(finalize_cache_transform_response);
327 struct cache_transform_response *
328 get_cache_transform_response(struct comm_element *element)
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);
339 init_cache_mp_write_session_request(
340 struct cache_mp_write_session_request *mp_ws_request)
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);
350 finalize_cache_mp_write_session_request(
351 struct cache_mp_write_session_request *mp_ws_request)
354 TRACE_IN(finalize_cache_mp_write_session_request);
355 free(mp_ws_request->entry);
356 TRACE_OUT(finalize_cache_mp_write_session_request);
359 struct cache_mp_write_session_request *
360 get_cache_mp_write_session_request(struct comm_element *element)
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);
370 init_cache_mp_write_session_response(
371 struct cache_mp_write_session_response *mp_ws_response)
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);
381 finalize_cache_mp_write_session_response(
382 struct cache_mp_write_session_response *mp_ws_response)
385 TRACE_IN(finalize_cache_mp_write_session_response);
386 TRACE_OUT(finalize_cache_mp_write_session_response);
389 struct cache_mp_write_session_response *
390 get_cache_mp_write_session_response(struct comm_element *element)
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);
400 init_cache_mp_write_session_write_request(
401 struct cache_mp_write_session_write_request *mp_ws_write_request)
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);
411 finalize_cache_mp_write_session_write_request(
412 struct cache_mp_write_session_write_request *mp_ws_write_request)
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);
420 struct cache_mp_write_session_write_request *
421 get_cache_mp_write_session_write_request(struct comm_element *element)
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);
431 init_cache_mp_write_session_write_response(
432 struct cache_mp_write_session_write_response *mp_ws_write_response)
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);
442 finalize_cache_mp_write_session_write_response(
443 struct cache_mp_write_session_write_response *mp_ws_write_response)
446 TRACE_IN(finalize_cache_mp_write_session_write_response);
447 TRACE_OUT(finalize_cache_mp_write_session_write_response);
450 struct cache_mp_write_session_write_response *
451 get_cache_mp_write_session_write_response(struct comm_element *element)
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);
461 init_cache_mp_read_session_request(
462 struct cache_mp_read_session_request *mp_rs_request)
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);
471 finalize_cache_mp_read_session_request(
472 struct cache_mp_read_session_request *mp_rs_request)
475 TRACE_IN(finalize_cache_mp_read_session_request);
476 free(mp_rs_request->entry);
477 TRACE_OUT(finalize_cache_mp_read_session_request);
480 struct cache_mp_read_session_request *
481 get_cache_mp_read_session_request(struct comm_element *element)
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);
491 init_cache_mp_read_session_response(
492 struct cache_mp_read_session_response *mp_rs_response)
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);
502 finalize_cache_mp_read_session_response(
503 struct cache_mp_read_session_response *mp_rs_response)
506 TRACE_IN(finalize_cache_mp_read_session_response);
507 TRACE_OUT(finalize_cache_mp_read_session_response);
510 struct cache_mp_read_session_response *
511 get_cache_mp_read_session_response(struct comm_element *element)
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);
521 init_cache_mp_read_session_read_response(
522 struct cache_mp_read_session_read_response *mp_ws_read_response)
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);
532 finalize_cache_mp_read_session_read_response(
533 struct cache_mp_read_session_read_response *mp_rs_read_response)
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);
541 struct cache_mp_read_session_read_response *
542 get_cache_mp_read_session_read_response(struct comm_element *element)
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);