libclient/src/tapi_common_sipc.c

   1 /*
   2  * tel-plugin-socket-communicator
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@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 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "sipc_log.h"
  26 #include "tapi_common_sipc.h"
  27
  28 static sipc_marshal_data_type_e _convert_marshal_data_type(tapi_object_data_type_e type)
  29 {
  30         switch(type){
  31                 case TAPI_OBJECT_DATA_TYPE_CHAR:{
  32                         return SIPC_MARSHAL_DATA_CHAR_TYPE;
  33                 }
  34                 case TAPI_OBJECT_DATA_TYPE_BOOLEAN:{
  35                         return SIPC_MARSHAL_DATA_BOOLEAN_TYPE;
  36                 }
  37                 case TAPI_OBJECT_DATA_TYPE_INT:{
  38                         return SIPC_MARSHAL_DATA_INT_TYPE;
  39                 }
  40                 case TAPI_OBJECT_DATA_TYPE_DOUBLE:{
  41                         return SIPC_MARSHAL_DATA_DOUBLE_TYPE;
  42                 }
  43                 case TAPI_OBJECT_DATA_TYPE_STRING:{
  44                         return SIPC_MARSHAL_DATA_STRING_TYPE;
  45                 }
  46                 case TAPI_OBJECT_DATA_TYPE_OBJECT:{
  47                         return SIPC_MARSHAL_DATA_OBJECT_TYPE;
  48                 }
  49         }
  50
  51         return SIPC_MARSHAL_DATA_STRING_MAX;
  52 }
  53
  54 static struct _tapi_header* _create_header( struct _tapi_handle *hdl, tapi_service_command_e c, unsigned int data_len )
  55 {
  56         struct _tapi_header *hdr = 0;
  57         hdr = g_new0( struct _tapi_header, 1 );
  58
  59         memcpy( hdr->cookie, hdl->cookie, 20 );
  60         memcpy( hdr->app_name, hdl->app_name, 16 );
  61         memcpy( hdr->cp_name, hdl->cp_name, 16 );
  62
  63         hdr->cmd = c;
  64         hdr->data_len = data_len;
  65
  66         return hdr;
  67 }
  68
  69 static gchar* _tapi_service_object_serializer(struct _tapi_service_object *so)
  70 {
  71         return sipc_util_marshal_object_serializer(so->mo);
  72 }
  73
  74 static sipc_marshal_object_t* _tapi_service_object_deserializer(const gchar* inparam)
  75 {
  76         return sipc_util_marshal_object_deserializer(inparam);
  77 }
  78
  79 struct _tapi_service_object* _tapi_service_object_create( tapi_service_command_e c )
  80 {
  81         struct _tapi_service_object *so = 0;
  82         so = g_new0( struct _tapi_service_object, 1 );
  83
  84         so->cmd = c;
  85         so->mo  = sipc_util_marshal_object_create();
  86         if ( !so->mo ) {
  87                 g_free( so );
  88
  89                 return 0;
  90         }
  91
  92         return so;
  93 }
  94
  95 gboolean _tapi_service_object_add_data(struct _tapi_service_object *so, const gchar* key, void *data, tapi_object_data_type_e type)
  96 {
  97         if(type != TAPI_OBJECT_DATA_TYPE_OBJECT)
  98                 return sipc_util_marshal_object_add_data(so->mo, key, data, _convert_marshal_data_type(type) );
  99
 100         return sipc_util_marshal_object_add_data(so->mo, key, ((struct _tapi_service_object *)data)->mo , _convert_marshal_data_type(type) );
 101 }
 102
 103 gboolean _tapi_service_object_get_data(const struct _tapi_service_object *so, const gchar* key, void **data, tapi_object_data_type_e type)
 104 {
 105         if(type == TAPI_OBJECT_DATA_TYPE_OBJECT){
 106                 *data = g_new0( struct _tapi_service_object, 1 );
 107                 ((struct _tapi_service_object *)(*data))->cmd = TAPI_SERVICE_UNKNOWN;
 108                 sipc_util_marshal_object_get_data(so->mo, key, (void **)&(((struct _tapi_service_object *)(*data))->mo), _convert_marshal_data_type(type) );
 109                 return TRUE;
 110         }
 111
 112         return sipc_util_marshal_object_get_data(so->mo, key, data, _convert_marshal_data_type(type) );
 113 }
 114
 115 gchar _tapi_service_object_get_char(const struct _tapi_service_object *so, const gchar* key)
 116 {
 117         return sipc_util_marshal_object_get_char(so->mo, key);
 118 }
 119
 120 gboolean _tapi_service_object_get_boolean(const struct _tapi_service_object *so, const gchar* key)
 121 {
 122         return sipc_util_marshal_object_get_boolean(so->mo, key);
 123 }
 124
 125 gint _tapi_service_object_get_int(const struct _tapi_service_object *so, const gchar* key)
 126 {
 127         return sipc_util_marshal_object_get_int(so->mo, key);
 128 }
 129
 130 gdouble _tapi_service_object_get_double(const struct _tapi_service_object *so, const gchar* key)
 131 {
 132         return sipc_util_marshal_object_get_double(so->mo, key);
 133 }
 134
 135 gchar* _tapi_service_object_get_string(const struct _tapi_service_object *so, const gchar* key)
 136 {
 137         return sipc_util_marshal_object_get_string(so->mo, key);
 138 }
 139
 140 struct _tapi_service_object* _tapi_service_object_get_object(const struct _tapi_service_object *so, const gchar* key)
 141 {
 142         struct _tapi_service_object *rvalue = 0;
 143         rvalue = g_new0( struct _tapi_service_object, 1 );
 144
 145         rvalue->cmd = TAPI_SERVICE_UNKNOWN;
 146         rvalue->mo  = sipc_util_marshal_object_get_object(so->mo, key);
 147         if ( !rvalue->mo ) {
 148                 g_free( rvalue );
 149                 return NULL;
 150         }
 151
 152         return rvalue;
 153 }
 154
 155 struct _tapi_service_object* _tapi_service_object_extract_async_data(const gchar *data)
 156 {
 157         struct _tapi_service_object *so = 0;
 158         so = g_new0( struct _tapi_service_object, 1 );
 159
 160         so->cmd = 0;
 161         so->mo = _tapi_service_object_deserializer(data);
 162         if (!so->mo) {
 163                 g_free(so);
 164                 return NULL;
 165         }
 166
 167         return so;
 168 }
 169
 170 gboolean _tapi_service_object_remove_data(struct _tapi_service_object *so, const gchar* key)
 171 {
 172         return sipc_util_marshal_object_remove_data(so->mo, key);
 173 }
 174
 175 gboolean _tapi_service_object_remove_alldata(struct _tapi_service_object *so)
 176 {
 177         return sipc_util_marshal_object_remove_alldata(so->mo);
 178 }
 179
 180 gboolean _tapi_service_object_destory(struct _tapi_service_object *so)
 181 {
 182         gboolean rv = FALSE;
 183         if(!so) return TRUE;
 184
 185         rv = sipc_util_marshal_object_destory(so->mo);
 186         g_free(so);
 187
 188         return TRUE;
 189 }
 190
 191 gboolean _tapi_send_service_request_sync(struct _tapi_handle *h, struct _tapi_service_object *in_d, struct _tapi_service_object *out_d)
 192 {
 193         int ret = 0;
 194         int serialized_data_len = 0, data_len = 0;
 195         gchar *data = NULL, *o_data = NULL;
 196         gchar *serialized_d = NULL;
 197         struct _tapi_header *hdr;
 198
 199         serialized_d = _tapi_service_object_serializer(in_d);
 200         if(serialized_d){
 201                 serialized_data_len = strlen(serialized_d);
 202                 //dbg("serialized data (%s)", serialized_d);
 203         }
 204
 205         hdr = _create_header( h, in_d->cmd, serialized_data_len );
 206
 207         data = g_new0(char, sizeof(struct _tapi_header)+serialized_data_len);
 208         memcpy(data, hdr, sizeof(struct _tapi_header));
 209         data_len = sizeof(struct _tapi_header);
 210
 211         if(serialized_data_len > 0){
 212                 memcpy( (data+data_len), serialized_d, serialized_data_len);
 213                 data_len = data_len+serialized_data_len;
 214         }
 215
 216         g_free(hdr);
 217         g_free(serialized_d);
 218
 219         ret = sipc_channel_send( h->tx_ch, data, data_len, (void **)&o_data, SIPC_DATA_TYPE_SYNC );
 220         if(ret < 0){
 221                 dbg("fail to send data");
 222                 return FALSE;
 223         }
 224
 225         if(o_data && out_d){
 226                 //dbg("return data (%s)", o_data);
 227                 sipc_util_marshal_object_destory(out_d->mo);
 228                 out_d->mo = _tapi_service_object_deserializer(o_data);
 229                 g_free(o_data);
 230         }
 231
 232         dbg("success to send data (%d)", data_len);
 233         g_free(data);
 234
 235         return TRUE;
 236 }