/*- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru> * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * */ #include <sys/cdefs.h> #include <assert.h> #include <stdlib.h> #include <string.h> #include "debug.h" #include "log.h" #include "protocol.h" /* * Initializes the comm_element with any given type of data */ void init_comm_element(struct comm_element *element, enum comm_element_t type) { TRACE_IN(init_comm_element); memset(element, 0, sizeof(struct comm_element)); switch (type) { case CET_WRITE_REQUEST: init_cache_write_request(&element->c_write_request); break; case CET_WRITE_RESPONSE: init_cache_write_response(&element->c_write_response); break; case CET_READ_REQUEST: init_cache_read_request(&element->c_read_request); break; case CET_READ_RESPONSE: init_cache_read_response(&element->c_read_response); break; case CET_TRANSFORM_REQUEST: init_cache_transform_request(&element->c_transform_request); break; case CET_TRANSFORM_RESPONSE: init_cache_transform_response(&element->c_transform_response); break; case CET_MP_WRITE_SESSION_REQUEST: init_cache_mp_write_session_request(&element->c_mp_ws_request); break; case CET_MP_WRITE_SESSION_RESPONSE: init_cache_mp_write_session_response(&element->c_mp_ws_response); break; case CET_MP_WRITE_SESSION_WRITE_REQUEST: init_cache_mp_write_session_write_request( &element->c_mp_ws_write_request); break; case CET_MP_WRITE_SESSION_WRITE_RESPONSE: init_cache_mp_write_session_write_response( &element->c_mp_ws_write_response); break; case CET_MP_READ_SESSION_REQUEST: init_cache_mp_read_session_request(&element->c_mp_rs_request); break; case CET_MP_READ_SESSION_RESPONSE: init_cache_mp_read_session_response(&element->c_mp_rs_response); break; case CET_MP_READ_SESSION_READ_RESPONSE: init_cache_mp_read_session_read_response( &element->c_mp_rs_read_response); break; case CET_UNDEFINED: break; default: LOG_ERR_2("init_comm_element", "invalid communication element"); TRACE_OUT(init_comm_element); return; } element->type = type; TRACE_OUT(init_comm_element); } void finalize_comm_element(struct comm_element *element) { TRACE_IN(finalize_comm_element); switch (element->type) { case CET_WRITE_REQUEST: finalize_cache_write_request(&element->c_write_request); break; case CET_WRITE_RESPONSE: finalize_cache_write_response(&element->c_write_response); break; case CET_READ_REQUEST: finalize_cache_read_request(&element->c_read_request); break; case CET_READ_RESPONSE: finalize_cache_read_response(&element->c_read_response); break; case CET_TRANSFORM_REQUEST: finalize_cache_transform_request(&element->c_transform_request); break; case CET_TRANSFORM_RESPONSE: finalize_cache_transform_response( &element->c_transform_response); break; case CET_MP_WRITE_SESSION_REQUEST: finalize_cache_mp_write_session_request( &element->c_mp_ws_request); break; case CET_MP_WRITE_SESSION_RESPONSE: finalize_cache_mp_write_session_response( &element->c_mp_ws_response); break; case CET_MP_WRITE_SESSION_WRITE_REQUEST: finalize_cache_mp_write_session_write_request( &element->c_mp_ws_write_request); break; case CET_MP_WRITE_SESSION_WRITE_RESPONSE: finalize_cache_mp_write_session_write_response( &element->c_mp_ws_write_response); break; case CET_MP_READ_SESSION_REQUEST: finalize_cache_mp_read_session_request( &element->c_mp_rs_request); break; case CET_MP_READ_SESSION_RESPONSE: finalize_cache_mp_read_session_response( &element->c_mp_rs_response); break; case CET_MP_READ_SESSION_READ_RESPONSE: finalize_cache_mp_read_session_read_response( &element->c_mp_rs_read_response); break; case CET_UNDEFINED: break; default: break; } element->type = CET_UNDEFINED; TRACE_OUT(finalize_comm_element); } void init_cache_write_request(struct cache_write_request *write_request) { TRACE_IN(init_cache_write_request); memset(write_request, 0, sizeof(struct cache_write_request)); TRACE_OUT(init_cache_write_request); } void finalize_cache_write_request(struct cache_write_request *write_request) { TRACE_IN(finalize_cache_write_request); free(write_request->entry); free(write_request->cache_key); free(write_request->data); TRACE_OUT(finalize_cache_write_request); } struct cache_write_request * get_cache_write_request(struct comm_element *element) { TRACE_IN(get_cache_write_request); assert(element->type == CET_WRITE_REQUEST); TRACE_OUT(get_cache_write_request); return (&element->c_write_request); } void init_cache_write_response(struct cache_write_response *write_response) { TRACE_IN(init_cache_write_response); memset(write_response, 0, sizeof(struct cache_write_response)); TRACE_OUT(init_cache_write_response); } void finalize_cache_write_response(struct cache_write_response *write_response) { TRACE_IN(finalize_cache_write_response); TRACE_OUT(finalize_cache_write_response); } struct cache_write_response * get_cache_write_response(struct comm_element *element) { TRACE_IN(get_cache_write_response); assert(element->type == CET_WRITE_RESPONSE); TRACE_OUT(get_cache_write_response); return (&element->c_write_response); } void init_cache_read_request(struct cache_read_request *read_request) { TRACE_IN(init_cache_read_request); memset(read_request, 0, sizeof(struct cache_read_request)); TRACE_OUT(init_cache_read_request); } void finalize_cache_read_request(struct cache_read_request *read_request) { TRACE_IN(finalize_cache_read_request); free(read_request->entry); free(read_request->cache_key); TRACE_OUT(finalize_cache_read_request); } struct cache_read_request * get_cache_read_request(struct comm_element *element) { TRACE_IN(get_cache_read_request); assert(element->type == CET_READ_REQUEST); TRACE_OUT(get_cache_read_request); return (&element->c_read_request); } void init_cache_read_response(struct cache_read_response *read_response) { TRACE_IN(init_cache_read_response); memset(read_response, 0, sizeof(struct cache_read_response)); TRACE_OUT(init_cache_read_response); } void finalize_cache_read_response(struct cache_read_response *read_response) { TRACE_IN(finalize_cache_read_response); free(read_response->data); TRACE_OUT(finalize_cache_read_response); } struct cache_read_response * get_cache_read_response(struct comm_element *element) { TRACE_IN(get_cache_read_response); assert(element->type == CET_READ_RESPONSE); TRACE_OUT(get_cache_read_response); return (&element->c_read_response); } void init_cache_transform_request(struct cache_transform_request *transform_request) { TRACE_IN(init_cache_transform_request); memset(transform_request, 0, sizeof(struct cache_transform_request)); TRACE_OUT(init_cache_transform_request); } void finalize_cache_transform_request( struct cache_transform_request *transform_request) { TRACE_IN(finalize_cache_transform_request); free(transform_request->entry); TRACE_OUT(finalize_cache_transform_request); } struct cache_transform_request * get_cache_transform_request(struct comm_element *element) { TRACE_IN(get_cache_transform_request); assert(element->type == CET_TRANSFORM_REQUEST); TRACE_OUT(get_cache_transform_request); return (&element->c_transform_request); } void init_cache_transform_response( struct cache_transform_response *transform_response) { TRACE_IN(init_cache_transform_request); memset(transform_response, 0, sizeof(struct cache_transform_response)); TRACE_OUT(init_cache_transform_request); } void finalize_cache_transform_response( struct cache_transform_response *transform_response) { TRACE_IN(finalize_cache_transform_response); TRACE_OUT(finalize_cache_transform_response); } struct cache_transform_response * get_cache_transform_response(struct comm_element *element) { TRACE_IN(get_cache_transform_response); assert(element->type == CET_TRANSFORM_RESPONSE); TRACE_OUT(get_cache_transform_response); return (&element->c_transform_response); } void init_cache_mp_write_session_request( struct cache_mp_write_session_request *mp_ws_request) { TRACE_IN(init_cache_mp_write_session_request); memset(mp_ws_request, 0, sizeof(struct cache_mp_write_session_request)); TRACE_OUT(init_cache_mp_write_session_request); } void finalize_cache_mp_write_session_request( struct cache_mp_write_session_request *mp_ws_request) { TRACE_IN(finalize_cache_mp_write_session_request); free(mp_ws_request->entry); TRACE_OUT(finalize_cache_mp_write_session_request); } struct cache_mp_write_session_request * get_cache_mp_write_session_request(struct comm_element *element) { TRACE_IN(get_cache_mp_write_session_request); assert(element->type == CET_MP_WRITE_SESSION_REQUEST); TRACE_OUT(get_cache_mp_write_session_request); return (&element->c_mp_ws_request); } void init_cache_mp_write_session_response( struct cache_mp_write_session_response *mp_ws_response) { TRACE_IN(init_cache_mp_write_session_response); memset(mp_ws_response, 0, sizeof(struct cache_mp_write_session_response)); TRACE_OUT(init_cache_mp_write_session_response); } void finalize_cache_mp_write_session_response( struct cache_mp_write_session_response *mp_ws_response) { TRACE_IN(finalize_cache_mp_write_session_response); TRACE_OUT(finalize_cache_mp_write_session_response); } struct cache_mp_write_session_response * get_cache_mp_write_session_response(struct comm_element *element) { TRACE_IN(get_cache_mp_write_session_response); assert(element->type == CET_MP_WRITE_SESSION_RESPONSE); TRACE_OUT(get_cache_mp_write_session_response); return (&element->c_mp_ws_response); } void init_cache_mp_write_session_write_request( struct cache_mp_write_session_write_request *mp_ws_write_request) { TRACE_IN(init_cache_mp_write_session_write_request); memset(mp_ws_write_request, 0, sizeof(struct cache_mp_write_session_write_request)); TRACE_OUT(init_cache_mp_write_session_write_response); } void finalize_cache_mp_write_session_write_request( struct cache_mp_write_session_write_request *mp_ws_write_request) { TRACE_IN(finalize_cache_mp_write_session_write_request); free(mp_ws_write_request->data); TRACE_OUT(finalize_cache_mp_write_session_write_request); } struct cache_mp_write_session_write_request * get_cache_mp_write_session_write_request(struct comm_element *element) { TRACE_IN(get_cache_mp_write_session_write_request); assert(element->type == CET_MP_WRITE_SESSION_WRITE_REQUEST); TRACE_OUT(get_cache_mp_write_session_write_request); return (&element->c_mp_ws_write_request); } void init_cache_mp_write_session_write_response( struct cache_mp_write_session_write_response *mp_ws_write_response) { TRACE_IN(init_cache_mp_write_session_write_response); memset(mp_ws_write_response, 0, sizeof(struct cache_mp_write_session_write_response)); TRACE_OUT(init_cache_mp_write_session_write_response); } void finalize_cache_mp_write_session_write_response( struct cache_mp_write_session_write_response *mp_ws_write_response) { TRACE_IN(finalize_cache_mp_write_session_write_response); TRACE_OUT(finalize_cache_mp_write_session_write_response); } struct cache_mp_write_session_write_response * get_cache_mp_write_session_write_response(struct comm_element *element) { TRACE_IN(get_cache_mp_write_session_write_response); assert(element->type == CET_MP_WRITE_SESSION_WRITE_RESPONSE); TRACE_OUT(get_cache_mp_write_session_write_response); return (&element->c_mp_ws_write_response); } void init_cache_mp_read_session_request( struct cache_mp_read_session_request *mp_rs_request) { TRACE_IN(init_cache_mp_read_session_request); memset(mp_rs_request, 0, sizeof(struct cache_mp_read_session_request)); TRACE_OUT(init_cache_mp_read_session_request); } void finalize_cache_mp_read_session_request( struct cache_mp_read_session_request *mp_rs_request) { TRACE_IN(finalize_cache_mp_read_session_request); free(mp_rs_request->entry); TRACE_OUT(finalize_cache_mp_read_session_request); } struct cache_mp_read_session_request * get_cache_mp_read_session_request(struct comm_element *element) { TRACE_IN(get_cache_mp_read_session_request); assert(element->type == CET_MP_READ_SESSION_REQUEST); TRACE_OUT(get_cache_mp_read_session_request); return (&element->c_mp_rs_request); } void init_cache_mp_read_session_response( struct cache_mp_read_session_response *mp_rs_response) { TRACE_IN(init_cache_mp_read_session_response); memset(mp_rs_response, 0, sizeof(struct cache_mp_read_session_response)); TRACE_OUT(init_cache_mp_read_session_response); } void finalize_cache_mp_read_session_response( struct cache_mp_read_session_response *mp_rs_response) { TRACE_IN(finalize_cache_mp_read_session_response); TRACE_OUT(finalize_cache_mp_read_session_response); } struct cache_mp_read_session_response * get_cache_mp_read_session_response(struct comm_element *element) { TRACE_IN(get_cache_mp_read_session_response); assert(element->type == CET_MP_READ_SESSION_RESPONSE); TRACE_OUT(get_cache_mp_read_session_response); return (&element->c_mp_rs_response); } void init_cache_mp_read_session_read_response( struct cache_mp_read_session_read_response *mp_ws_read_response) { TRACE_IN(init_cache_mp_read_session_read_response); memset(mp_ws_read_response, 0, sizeof(struct cache_mp_read_session_read_response)); TRACE_OUT(init_cache_mp_read_session_read_response); } void finalize_cache_mp_read_session_read_response( struct cache_mp_read_session_read_response *mp_rs_read_response) { TRACE_IN(finalize_cache_mp_read_session_read_response); free(mp_rs_read_response->data); TRACE_OUT(finalize_cache_mp_read_session_read_response); } struct cache_mp_read_session_read_response * get_cache_mp_read_session_read_response(struct comm_element *element) { TRACE_IN(get_cache_mp_read_session_read_response); assert(element->type == CET_MP_READ_SESSION_READ_RESPONSE); TRACE_OUT(get_cache_mp_read_session_read_response); return (&element->c_mp_rs_read_response); }