src/framework/engine-controller/message.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include "utility/sync_util.h"
  21 #include "engine-controller/message.h"
  22 #include "engine-controller/queuing_rule_spec_internal.h"
  23 #include "engine-controller/task_spec_internal.h"
  24
  25 #ifndef SYNC_AGENT_LOG
  26 #undef LOG_TAG
  27 #define LOG_TAG "AF_EC"
  28 #endif
  29
  30 void ec_msg_set_msg_head(ec_msg_head_t * msg_head, ec_msg_type_t msg_type, sync_agent_ec_uint msg_id)
  31 {
  32         _EXTERN_FUNC_ENTER;
  33
  34         if (msg_head != NULL) {
  35                 msg_head->msg_id = msg_id;
  36                 msg_head->msg_type = msg_type;
  37         }
  38
  39         _EXTERN_FUNC_EXIT;
  40 }
  41
  42 ec_register_msg_t *ec_msg_create_register_msg(sync_agent_ec_uint task_spec_id, sync_agent_ec_task_spec_s * task_spec, sync_agent_calculate_identifier_cb id_calc_func)
  43 {
  44         _EXTERN_FUNC_ENTER;
  45
  46         retvm_if(task_spec == NULL, NULL, "sync_agent_ec_task_spec_s is NULL !!");
  47
  48         ec_register_msg_t *register_msg = (ec_register_msg_t *) calloc(1, sizeof(ec_register_msg_t));
  49         if (register_msg == NULL) {
  50                 goto error_part;
  51         }
  52
  53         ec_msg_set_msg_head(&(register_msg->msg_head), EC_REGISTER_MSG_TYPE, 0);
  54
  55         register_msg->task_spec_id = task_spec_id;
  56         register_msg->task_spec = ec_task_spec_ref(task_spec);
  57         if (id_calc_func != NULL) {
  58                 register_msg->id_calc_func = id_calc_func;
  59         }
  60
  61         _EXTERN_FUNC_EXIT;
  62
  63         return register_msg;
  64  error_part:
  65         ec_msg_free_register_msg(register_msg);
  66         return NULL;
  67 }
  68
  69 void ec_msg_free_register_msg(ec_register_msg_t * register_msg)
  70 {
  71         _EXTERN_FUNC_ENTER;
  72
  73         if (register_msg != NULL) {
  74                 if (register_msg->task_spec != NULL) {
  75                         ec_task_spec_unref(register_msg->task_spec);
  76                 }
  77
  78                 free(register_msg);
  79         }
  80
  81         _EXTERN_FUNC_EXIT;
  82 }
  83
  84 ec_register_queuing_rule_spec_msg_t *ec_msg_create_register_queuing_rule_spec_msg(sync_agent_ec_queuing_rule_spec_s * spec, sync_agent_register_finish_cb register_finish_callback, sync_agent_ec_pointer usr_data)
  85 {
  86         _EXTERN_FUNC_ENTER;
  87
  88         ec_register_queuing_rule_spec_msg_t *msg = (ec_register_queuing_rule_spec_msg_t *) calloc(1, sizeof(ec_register_queuing_rule_spec_msg_t));
  89         if (msg == NULL) {
  90                 goto error_part;
  91         }
  92
  93         ec_msg_set_msg_head(&(msg->msg_head), EC_REGISTER_QUEUING_RULE_SPEC_MSG_TYPE, 0);
  94         msg->spec = ec_ref_queuing_rule_spec(spec);
  95
  96         msg->register_finish_callback = register_finish_callback;
  97         msg->usr_data = usr_data;
  98
  99         _EXTERN_FUNC_EXIT;
 100
 101         return msg;
 102  error_part:
 103         ec_msg_free_register_queuing_rule_spec_msg(msg);
 104         return NULL;
 105 }
 106
 107 void ec_msg_free_register_queuing_rule_spec_msg(ec_register_queuing_rule_spec_msg_t * msg)
 108 {
 109         _EXTERN_FUNC_ENTER;
 110
 111         retm_if(msg == NULL, "ec_register_queuing_rule_spec_msg_t is NULL !!");
 112
 113         if (msg != NULL) {
 114                 /* TODO */
 115         }
 116
 117         _EXTERN_FUNC_EXIT;
 118 }
 119
 120 ec_request_msg_t *ec_msg_create_request_msg(sync_agent_ec_uint task_spec_id, sync_agent_ec_uint identifier, sync_agent_ec_int cnt_in_param, sync_agent_ec_int * in_param_index_array, sync_agent_ec_value_type_e * in_param_value_type_array,
 121                                             sync_agent_ec_pointer * in_param_value_array, sync_agent_task_finish_cb task_finish_callback, sync_agent_ec_pointer simple_task_finish_callback_usr_data)
 122 {
 123         _EXTERN_FUNC_ENTER;
 124
 125         ec_request_msg_t *msg = (ec_request_msg_t *) calloc(1, sizeof(ec_request_msg_t));
 126         sync_agent_ec_int i = 0;
 127         if (msg == NULL) {
 128                 goto error_part;
 129         }
 130
 131         ec_msg_set_msg_head(&(msg->msg_head), EC_REQUEST_MSG_TYPE, 0);
 132         msg->task_spec_id = task_spec_id;
 133         msg->identifier = identifier;
 134         msg->cnt_in_param = cnt_in_param;
 135         if (cnt_in_param > 0) {
 136                 msg->in_param_index_array = (sync_agent_ec_int *) malloc(cnt_in_param * sizeof(sync_agent_ec_int));
 137                 if (msg->in_param_index_array == NULL) {
 138                         goto error_part;
 139                 }
 140                 memcpy(msg->in_param_index_array, in_param_index_array, cnt_in_param * sizeof(sync_agent_ec_int));
 141
 142                 msg->in_param_value_array = (sync_agent_ec_param_value_u *) calloc(cnt_in_param, sizeof(sync_agent_ec_param_value_u));
 143                 if (msg->in_param_value_array == NULL) {
 144                         goto error_part;
 145                 }
 146
 147                 for (i = 0; i < cnt_in_param; i++) {
 148                         sync_agent_set_param_value(&(msg->in_param_value_array[i]), in_param_value_type_array[i], in_param_value_array[i]);
 149                 }
 150         }
 151         msg->task_finish_callback = task_finish_callback;
 152         msg->simple_task_finish_callback_usr_data = simple_task_finish_callback_usr_data;
 153
 154         _EXTERN_FUNC_EXIT;
 155
 156         return msg;
 157
 158  error_part:
 159         ec_msg_free_request_msg(msg);
 160         return NULL;
 161 }
 162
 163 void ec_msg_free_request_msg(ec_request_msg_t * msg)
 164 {
 165         _EXTERN_FUNC_ENTER;
 166
 167         if (msg != NULL) {
 168                 /* TODO */
 169
 170                 free(msg);
 171         }
 172
 173         _EXTERN_FUNC_EXIT;
 174 }
 175
 176 ec_cancel_all_msg_t *ec_msg_create_cancel_all_msg()
 177 {
 178         _EXTERN_FUNC_ENTER;
 179
 180         ec_cancel_all_msg_t *cancel_all_msg = (ec_cancel_all_msg_t *) calloc(1, sizeof(ec_cancel_all_msg_t));
 181         if (cancel_all_msg == NULL) {
 182                 goto error_part;
 183         }
 184
 185         ec_msg_set_msg_head(&(cancel_all_msg->msg_head), EC_CANCEL_ALL_MSG_TYPE, 0);
 186
 187         _EXTERN_FUNC_EXIT;
 188
 189         return cancel_all_msg;
 190  error_part:
 191         ec_msg_free_cancel_all_msg(cancel_all_msg);
 192         return NULL;
 193 }
 194
 195 void ec_msg_free_cancel_all_msg(ec_cancel_all_msg_t * cancel_all_msg)
 196 {
 197         _EXTERN_FUNC_ENTER;
 198
 199         if (cancel_all_msg != NULL) {
 200                 /* TODO */
 201         }
 202
 203         _EXTERN_FUNC_EXIT;
 204 }
 205
 206 ec_cancel_msg_t *ec_msg_create_cancel_msg(sync_agent_ec_uint request_msg_id_to_cancel)
 207 {
 208         _EXTERN_FUNC_ENTER;
 209
 210         ec_cancel_msg_t *cancel_msg = (ec_cancel_msg_t *) calloc(1, sizeof(ec_cancel_msg_t));
 211         if (cancel_msg == NULL) {
 212                 goto error_part;
 213         }
 214
 215         ec_msg_set_msg_head(&(cancel_msg->msg_head), EC_CANCEL_MSG_TYPE, 0);
 216         cancel_msg->request_msg_id_to_cancel = request_msg_id_to_cancel;
 217
 218         _EXTERN_FUNC_EXIT;
 219
 220         return cancel_msg;
 221  error_part:
 222         ec_msg_free_cancel_msg(cancel_msg);
 223         return NULL;
 224 }
 225
 226 void ec_msg_free_cancel_msg(ec_cancel_msg_t * cancel_msg)
 227 {
 228         _EXTERN_FUNC_ENTER;
 229
 230         if (cancel_msg != NULL) {
 231                 /* TODO */
 232         }
 233
 234         _EXTERN_FUNC_EXIT;
 235 }
 236
 237 sync_agent_ec_boolean ec_msg_check_same_msg_type(ec_msg_head_t * pHead, ec_msg_type_t msg_type)
 238 {
 239         _EXTERN_FUNC_ENTER;
 240
 241         if (pHead->msg_type == msg_type) {
 242                 return true;
 243         } else {
 244                 return false;
 245         }
 246
 247         _EXTERN_FUNC_EXIT;
 248 }
 249
 250 sync_agent_ec_boolean ec_msg_is_register_msg(ec_msg_head_t * pHead)
 251 {
 252         _EXTERN_FUNC_ENTER;
 253
 254         _EXTERN_FUNC_EXIT;
 255
 256         return ec_msg_check_same_msg_type(pHead, EC_REGISTER_MSG_TYPE);
 257 }
 258
 259 sync_agent_ec_boolean ec_msg_is_unregister_msg(ec_msg_head_t * pHead)
 260 {
 261         _EXTERN_FUNC_ENTER;
 262
 263         _EXTERN_FUNC_EXIT;
 264
 265         return ec_msg_check_same_msg_type(pHead, EC_UNREGISTER_MSG_TYPE);
 266 }
 267
 268 sync_agent_ec_boolean ec_msg_is_register_queuing_rule_spec_msg(ec_msg_head_t * pHead)
 269 {
 270         _EXTERN_FUNC_ENTER;
 271
 272         _EXTERN_FUNC_EXIT;
 273
 274         return ec_msg_check_same_msg_type(pHead, EC_REGISTER_QUEUING_RULE_SPEC_MSG_TYPE);
 275 }
 276
 277 sync_agent_ec_boolean ec_msg_is_request_msg(ec_msg_head_t * pHead)
 278 {
 279         _EXTERN_FUNC_ENTER;
 280
 281         return ec_msg_check_same_msg_type(pHead, EC_REQUEST_MSG_TYPE);
 282 }
 283
 284 sync_agent_ec_boolean ec_msg_is_cancel_msg(ec_msg_head_t * pHead)
 285 {
 286         _EXTERN_FUNC_ENTER;
 287
 288         _EXTERN_FUNC_EXIT;
 289
 290         return ec_msg_check_same_msg_type(pHead, EC_CANCEL_MSG_TYPE);
 291 }
 292
 293 sync_agent_ec_boolean ec_msg_is_cancel_all_msg(ec_msg_head_t * pHead)
 294 {
 295         _EXTERN_FUNC_ENTER;
 296
 297         _EXTERN_FUNC_EXIT;
 298
 299         return ec_msg_check_same_msg_type(pHead, EC_CANCEL_ALL_MSG_TYPE);
 300 }