src/tapi_oem.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2014 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 "tapi_common.h"
  26 #include "TapiUtility.h"
  27
  28 #include "common.h"
  29 #include "tapi_log.h"
  30 #include "ITapiOem.h"
  31 #include "TelOem.h"
  32 #include "tapi_private.h"
  33
  34 #define OEM_DATA_LEN_MAX        (10 * 1024)
  35 #define OEM_DEFAULT_TIMEOUT     (30 * 1000)
  36
  37 struct oem_resp_data {
  38         struct tapi_handle *handle;
  39         void* user_data;
  40         tapi_response_cb cb_fn;
  41         int oem_id;
  42 };
  43
  44 #define MAKE_OEM_RESP_CB_DATA(data, handle, cb, user_data, oem_id)  do { \
  45         if (!handle) \
  46                 return TAPI_API_INVALID_INPUT; \
  47         \
  48         data = g_try_malloc0(sizeof(struct oem_resp_data)); \
  49         if (data == NULL) \
  50                 return TAPI_API_SYSTEM_OUT_OF_MEM; \
  51         data->handle = handle; \
  52         data->cb_fn = cb; \
  53         data->user_data = user_data; \
  54         data->oem_id = oem_id; \
  55 } while (0)
  56
  57 /* LCOV_EXCL_START */
  58 static void on_response_oem_data_async(GObject *source_object,
  59         GAsyncResult *res, gpointer user_data)
  60 {
  61         GError *error = NULL;
  62         struct oem_resp_data *evt_cb_data = user_data;
  63         int result = -1;
  64         GVariant *dbus_result;
  65         TelOemData_t oem_data = {0};
  66         gchar *data = NULL;
  67
  68         dbus_result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error);
  69         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
  70
  71         g_variant_get(dbus_result, "(is)", &oem_data.oem_id, &data);
  72
  73         oem_data.data = g_base64_decode((const gchar *)data, (gsize *)&oem_data.data_len);
  74         if (oem_data.data) {
  75                 result = TAPI_API_SUCCESS;
  76
  77                 dbg("id:[0x%x] len:[%d]", oem_data.oem_id, oem_data.data_len);
  78
  79                 TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &oem_data);
  80
  81                 g_free(oem_data.data);
  82         } else {
  83                 TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
  84         }
  85
  86         g_free(data);
  87
  88         g_free(evt_cb_data);
  89         g_variant_unref(dbus_result);
  90 }
  91
  92 EXPORT_API int tel_send_oem_data(TapiHandle *handle, int oem_id,
  93         void *data, unsigned int data_len)
  94 {
  95         GError *error = NULL;
  96         GVariant *rst = NULL;
  97         GVariant *inparam = NULL;
  98         gint result;
  99         gchar *encoded_data = NULL;
 100
 101         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 102         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 103         TAPI_RET_ERR_NUM_IF_FAIL(handle->dbus_connection, TAPI_API_INVALID_PTR);
 104         TAPI_RET_ERR_NUM_IF_FAIL(data, TAPI_API_INVALID_PTR);
 105
 106         dbg("oem_id(0x%x) data(%p) data len(%d)", oem_id, data, data_len);
 107
 108         if (data_len > OEM_DATA_LEN_MAX)
 109                 return TAPI_API_INVALID_INPUT;
 110
 111         encoded_data = g_base64_encode((const guchar *)data, data_len);
 112         inparam = g_variant_new("(is)", oem_id, encoded_data);
 113
 114         rst = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
 115                 handle->path, DBUS_TELEPHONY_OEM_INTERFACE,
 116                 "SendOemData", inparam, NULL, G_DBUS_CALL_FLAGS_NONE,
 117                 TAPI_DEFAULT_TIMEOUT, handle->ca, &error);
 118         g_free(encoded_data);
 119         if (!rst) {
 120                 dbg("error to data(%s)", error->message);
 121                 g_error_free(error);
 122                 return TAPI_API_OPERATION_FAILED;
 123         }
 124
 125         g_variant_get(rst, "(i)", &result);
 126         if (result) {
 127                 result = TAPI_API_SUCCESS;
 128         } else {
 129                 dbg("error (%d)", result);
 130                 result = TAPI_API_OPERATION_FAILED;
 131         }
 132         g_variant_unref(rst);
 133         return result;
 134 }
 135
 136 EXPORT_API int tel_send_oem_data_sync(TapiHandle *handle, int oem_id,
 137         void *data, unsigned int data_len, TelOemData_t *outparam)
 138 {
 139         GError *error = NULL;
 140         GVariant *inparam = NULL;
 141         gchar *encoded_data = NULL;
 142         GVariant *rst = NULL;
 143         gchar *pdata = NULL;
 144
 145         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 146         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 147         TAPI_RET_ERR_NUM_IF_FAIL(handle->dbus_connection, TAPI_API_INVALID_PTR);
 148         TAPI_RET_ERR_NUM_IF_FAIL(data, TAPI_API_INVALID_PTR);
 149
 150         dbg("oem_id(0x%x) data(%p) data len(%d)", oem_id, data, data_len);
 151
 152         if (data_len > OEM_DATA_LEN_MAX)
 153                 return TAPI_API_INVALID_INPUT;
 154
 155         encoded_data = g_base64_encode((const guchar *)data, data_len);
 156         inparam = g_variant_new("(is)", oem_id, encoded_data);
 157
 158         rst = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
 159                 handle->path, DBUS_TELEPHONY_OEM_INTERFACE,
 160                 "SendOemDataWithResponse", inparam, NULL, G_DBUS_CALL_FLAGS_NONE,
 161                 TAPI_DEFAULT_TIMEOUT, handle->ca, &error);
 162         g_free(encoded_data);
 163
 164         if (!rst) {
 165                 dbg("error to data(%s)", error->message);
 166                 g_error_free(error);
 167                 return TAPI_API_OPERATION_FAILED;
 168         }
 169
 170         g_variant_get(rst, "(is)", &outparam->oem_id, &pdata);
 171
 172         outparam->data = g_base64_decode((const gchar *)pdata, (gsize *)&outparam->data_len);
 173         if (outparam->data_len)
 174                 dbg("id:[0x%x] len:[%d]", outparam->oem_id, outparam->data_len);
 175
 176         g_free(pdata);
 177         g_variant_unref(rst);
 178
 179         return TAPI_API_SUCCESS;
 180 }
 181
 182 EXPORT_API int tel_send_oem_data_async(TapiHandle *handle, int oem_id,
 183         void *data, unsigned int data_len, tapi_response_cb callback, void *user_data)
 184 {
 185         GVariant *inparam = NULL;
 186         gchar *encoded_data = NULL;
 187         struct oem_resp_data *evt_cb_data = NULL;
 188
 189         TAPI_RET_ERR_NUM_IF_NOT_SUPPORTED(TELEPHONY_FEATURE);
 190         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 191         TAPI_RET_ERR_NUM_IF_FAIL(handle->dbus_connection, TAPI_API_INVALID_PTR);
 192         TAPI_RET_ERR_NUM_IF_FAIL(data, TAPI_API_INVALID_PTR);
 193
 194         if (data_len > OEM_DATA_LEN_MAX)
 195                 return TAPI_API_INVALID_INPUT;
 196
 197         dbg("oem_id(0x%x) data(%p) data len(%d)", oem_id, data, data_len);
 198
 199         MAKE_OEM_RESP_CB_DATA(evt_cb_data, handle, callback, user_data, oem_id);
 200
 201         encoded_data = g_base64_encode((const guchar *)data, data_len);
 202         inparam = g_variant_new("(is)", oem_id, encoded_data);
 203
 204         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
 205                 handle->path, DBUS_TELEPHONY_OEM_INTERFACE,
 206                 "SendOemDataWithResponse", inparam, NULL, G_DBUS_CALL_FLAGS_NONE,
 207                 OEM_DEFAULT_TIMEOUT, handle->ca, on_response_oem_data_async, evt_cb_data);
 208
 209         g_free(encoded_data);
 210
 211         return TAPI_API_SUCCESS;
 212 }
 213 /* LCOV_EXCL_STOP */