email-api/email-api-rule.c

   1 /*
   2 *  email-service
   3 *
   4 * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5 *
   6 * Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>
   7 *
   8 * Licensed under the Apache License, Version 2.0 (the "License");
   9 * you may not use this file except in compliance with the License.
  10 * You may obtain a copy of the License at
  11 *
  12 * http://www.apache.org/licenses/LICENSE-2.0
  13 *
  14 * Unless required by applicable law or agreed to in writing, software
  15 * distributed under the License is distributed on an "AS IS" BASIS,
  16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 * See the License for the specific language governing permissions and
  18 * limitations under the License.
  19 *
  20 */
  21
  22
  23
  24 /**
  25  *
  26  * This file contains the data structures and interfaces needed for application,
  27  * to interact with email-service.
  28  * @file                email-api-rule.c
  29  * @brief               This file contains the data structures and interfaces of Rule related Functionality provided by
  30  *                      email-service .
  31  */
  32
  33 #include "email-api.h"
  34 #include "string.h"
  35 #include "email-convert.h"
  36 #include "email-storage.h"
  37 #include "email-utilities.h"
  38 #include "email-ipc.h"
  39
  40 EXPORT_API int email_get_rule(int filter_id, email_rule_t** filtering_set)
  41 {
  42         EM_DEBUG_FUNC_BEGIN("filter_id[%d], filtering_set[%p]", filter_id, filtering_set);
  43
  44         int err = 0;
  45
  46         EM_IF_NULL_RETURN_VALUE(filtering_set, EMAIL_ERROR_INVALID_PARAM);
  47         EM_IF_NULL_RETURN_VALUE(filter_id, EMAIL_ERROR_INVALID_PARAM);
  48
  49         if (!emstorage_get_rule_by_id(0, filter_id, (emstorage_rule_tbl_t**)filtering_set, true, &err))  {
  50                 EM_DEBUG_EXCEPTION("emstorage_get_rule_by_id failed [%d]", err);
  51
  52                 goto FINISH_OFF;
  53         } else
  54                 err = EMAIL_ERROR_NONE;
  55
  56 FINISH_OFF:
  57         EM_DEBUG_FUNC_END("error value [%d]", err);
  58         return err;
  59 }
  60
  61
  62 EXPORT_API int email_get_rule_list(email_rule_t** filtering_set, int* count)
  63 {
  64         EM_DEBUG_FUNC_BEGIN();
  65
  66         int err = EMAIL_ERROR_NONE;
  67         int is_completed = 0;
  68
  69         EM_IF_NULL_RETURN_VALUE(filtering_set, EMAIL_ERROR_INVALID_PARAM);
  70         EM_IF_NULL_RETURN_VALUE(count, EMAIL_ERROR_INVALID_PARAM);
  71
  72         *count = 1000;
  73
  74         if (!emstorage_get_rule(0, 0, 0, count, &is_completed, (emstorage_rule_tbl_t**)filtering_set, true, &err))  {
  75                 EM_DEBUG_EXCEPTION("emstorage_get_rule failed [%d]", err);
  76
  77
  78                 goto FINISH_OFF;
  79         } else
  80                 err = EMAIL_ERROR_NONE;
  81
  82
  83 FINISH_OFF:
  84
  85         return err;
  86
  87 }
  88
  89 EXPORT_API int email_add_rule(email_rule_t* filtering_set)
  90 {
  91         EM_DEBUG_FUNC_BEGIN("filtering_set[%p]", filtering_set);
  92
  93         int size = 0;
  94         int err = EMAIL_ERROR_NONE;
  95         char* stream = NULL;
  96
  97         EM_IF_NULL_RETURN_VALUE(filtering_set, EMAIL_ERROR_INVALID_PARAM);
  98
  99         /* make rule info */
 100         HIPC_API hAPI = emipc_create_email_api(_EMAIL_API_ADD_RULE);
 101         EM_IF_NULL_RETURN_VALUE(hAPI, EMAIL_ERROR_NULL_VALUE);
 102
 103         stream = em_convert_rule_to_byte_stream(filtering_set, &size);
 104         EM_PROXY_IF_NULL_RETURN_VALUE(stream, hAPI, EMAIL_ERROR_NULL_VALUE);
 105         if(!emipc_add_dynamic_parameter(hAPI, ePARAMETER_IN, stream, size)) {
 106                 EM_DEBUG_EXCEPTION("Add Param Failed");
 107                 EM_PROXY_IF_NULL_RETURN_VALUE(0, hAPI, EMAIL_ERROR_NULL_VALUE);
 108         }
 109
 110         /* pass rule info */
 111         if(emipc_execute_proxy_api(hAPI) != EMAIL_ERROR_NONE) {
 112                 EM_DEBUG_EXCEPTION("emipc_execute_proxy_api Failed");
 113                 EM_PROXY_IF_NULL_RETURN_VALUE(0, hAPI, EMAIL_ERROR_IPC_SOCKET_FAILURE);
 114         }
 115
 116         emipc_get_parameter(hAPI, ePARAMETER_OUT, 0, sizeof(int), &err);
 117
 118         emipc_destroy_email_api(hAPI);
 119         hAPI = NULL;
 120         EM_DEBUG_FUNC_END("error value [%d]", err);
 121         return err;
 122 }
 123
 124
 125
 126 EXPORT_API int email_update_rule(int filter_id, email_rule_t* new_set)
 127 {
 128         EM_DEBUG_FUNC_BEGIN("filter_id[%d], new_set[%p]", filter_id, new_set);
 129
 130         int size = 0;
 131         char* stream =  NULL;
 132         int err = EMAIL_ERROR_NONE;
 133
 134         EM_IF_NULL_RETURN_VALUE(filter_id, EMAIL_ERROR_INVALID_PARAM);
 135         EM_IF_NULL_RETURN_VALUE(new_set, EMAIL_ERROR_INVALID_PARAM);
 136
 137         HIPC_API hAPI = emipc_create_email_api(_EMAIL_API_UPDATE_RULE);
 138         EM_IF_NULL_RETURN_VALUE(hAPI, EMAIL_ERROR_NULL_VALUE);
 139
 140         /* make filter info */
 141         if(!emipc_add_parameter(hAPI, ePARAMETER_IN, (char*)&filter_id, sizeof(int))) {
 142                 EM_DEBUG_EXCEPTION("Add Param filter_id Failed");
 143                 EM_PROXY_IF_NULL_RETURN_VALUE(0, hAPI, EMAIL_ERROR_NULL_VALUE);
 144         }
 145
 146         stream = em_convert_rule_to_byte_stream(new_set, &size);
 147         if(NULL == stream) {
 148                 EM_PROXY_IF_NULL_RETURN_VALUE(0, hAPI, EMAIL_ERROR_NULL_VALUE);
 149         }
 150         if(!emipc_add_dynamic_parameter(hAPI, ePARAMETER_IN, stream, size)){
 151                 EM_DEBUG_EXCEPTION("Add Param new_set Failed");
 152                 EM_PROXY_IF_NULL_RETURN_VALUE(0, hAPI, EMAIL_ERROR_NULL_VALUE);
 153         }
 154
 155         /* request update rule with filter info */
 156         if(emipc_execute_proxy_api(hAPI) != EMAIL_ERROR_NONE) {
 157                 EM_DEBUG_EXCEPTION("emipc_execute_proxy_api Failed");
 158                 EM_PROXY_IF_NULL_RETURN_VALUE(0, hAPI, EMAIL_ERROR_IPC_SOCKET_FAILURE);
 159         }
 160
 161         /* get result */
 162         emipc_get_parameter(hAPI, ePARAMETER_OUT, 0, sizeof(int), &err);
 163
 164         emipc_destroy_email_api(hAPI);
 165
 166         hAPI = NULL;
 167         EM_DEBUG_FUNC_END("error value [%d]", err);
 168         return err;
 169 }
 170
 171
 172
 173
 174 EXPORT_API int email_delete_rule(int filter_id)
 175 {
 176         EM_DEBUG_FUNC_BEGIN("filter_id[%d]", filter_id);
 177
 178         int err = EMAIL_ERROR_NONE;
 179
 180         EM_IF_NULL_RETURN_VALUE(filter_id, EMAIL_ERROR_INVALID_PARAM);
 181
 182         HIPC_API hAPI = emipc_create_email_api(_EMAIL_API_DELETE_RULE);
 183
 184         EM_IF_NULL_RETURN_VALUE(hAPI, EMAIL_ERROR_NULL_VALUE);
 185
 186         /* filter_id */
 187         if(!emipc_add_parameter(hAPI, ePARAMETER_IN, (char*)&filter_id, sizeof(int))) {
 188                 EM_DEBUG_EXCEPTION("emipc_add_parameter failed");
 189                 EM_PROXY_IF_NULL_RETURN_VALUE(0, hAPI, EMAIL_ERROR_NULL_VALUE);
 190         }
 191
 192         if(emipc_execute_proxy_api(hAPI) != EMAIL_ERROR_NONE) {
 193                 EM_DEBUG_EXCEPTION("emipc_execute_proxy_api failed");
 194                 EM_PROXY_IF_NULL_RETURN_VALUE(0, hAPI, EMAIL_ERROR_IPC_SOCKET_FAILURE);
 195         }
 196
 197         emipc_get_parameter(hAPI, ePARAMETER_OUT, 0, sizeof(int), &err);
 198         emipc_destroy_email_api(hAPI);
 199
 200         hAPI = NULL;
 201         EM_DEBUG_FUNC_END("error value [%d]", err);
 202         return err;
 203 }
 204
 205 EXPORT_API int email_free_rule (email_rule_t** filtering_set, int count)
 206 {
 207         EM_DEBUG_FUNC_BEGIN();
 208         int err = EMAIL_ERROR_NONE, i;
 209
 210         EM_IF_NULL_RETURN_VALUE(filtering_set, EMAIL_ERROR_INVALID_PARAM);
 211         EM_IF_NULL_RETURN_VALUE(count, EMAIL_ERROR_INVALID_PARAM);
 212
 213         if (count > 0)  {
 214                 email_rule_t* p = *filtering_set;
 215
 216                 for (i = 0; i < count; i++) {
 217                         EM_SAFE_FREE(p[i].value);
 218                 }
 219
 220                 EM_SAFE_FREE(p); *filtering_set = NULL;
 221         }
 222
 223         EM_DEBUG_FUNC_END("error value [%d]", err);
 224         return err;
 225 }
 226
 227