src/data_control_map.c

   1 /*
   2  * Copyright (c) 2013 - 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <errno.h>
  18 #include <glib.h>
  19 #include <stdbool.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22
  23 #include <bundle.h>
  24 #include "data_control_internal.h"
  25 #include "data_control_bulk.h"
  26 #include "data_control_map.h"
  27 #include "data_control_log.h"
  28
  29 EXPORT_API int data_control_map_create(data_control_h *provider)
  30 {
  31         return _create_data_control_h(provider);
  32 }
  33
  34 EXPORT_API int data_control_map_destroy(data_control_h provider)
  35 {
  36         return _destroy_data_control_h(provider, true);
  37 }
  38
  39 EXPORT_API int data_control_map_set_provider_id(data_control_h provider,
  40                 const char *provider_id)
  41 {
  42         return _set_provider_id(provider, provider_id);
  43 }
  44
  45 EXPORT_API int data_control_map_get_provider_id(data_control_h provider,
  46                 char **provider_id)
  47 {
  48         return _get_provider_id(provider, provider_id);
  49 }
  50
  51 EXPORT_API int data_control_map_set_data_id(data_control_h provider,
  52                 const char *data_id)
  53 {
  54         return _set_data_id(provider, data_id);
  55 }
  56
  57 EXPORT_API int data_control_map_get_data_id(data_control_h provider,
  58                 char **data_id)
  59 {
  60         return _get_data_id(provider, data_id);
  61 }
  62
  63 EXPORT_API int data_control_map_get_handle_id(data_control_h provider,
  64                 int *handle_id)
  65 {
  66         return _get_handle_id(provider, handle_id);
  67 }
  68
  69 EXPORT_API int data_control_map_register_response_cb(data_control_h provider,
  70                 data_control_map_response_cb *callback, void *user_data)
  71 {
  72         return _register_response_cb(provider, (void *)callback,
  73                         false, DATACONTROL_TYPE_MAP_GET, user_data);
  74 }
  75
  76 EXPORT_API int data_control_map_unregister_response_cb(data_control_h provider)
  77 {
  78         return _unregister_response_cb(provider, false, DATACONTROL_TYPE_MAP_GET);
  79 }
  80
  81 EXPORT_API int data_control_map_register_add_bulk_data_response_cb(
  82                 data_control_h provider,
  83                 data_control_bulk_cb callback,
  84                 void *user_data)
  85 {
  86         return _register_response_cb(provider, (void *)callback,
  87                         false, DATACONTROL_TYPE_MAP_BULK_ADD, user_data);
  88 }
  89
  90 EXPORT_API int data_control_map_unregister_add_bulk_data_response_cb(
  91                 data_control_h provider)
  92 {
  93         return _unregister_response_cb(provider, false,
  94                         DATACONTROL_TYPE_MAP_BULK_ADD);
  95 }
  96
  97 EXPORT_API int data_control_map_bind_response_cb(data_control_h provider,
  98                 data_control_map_response_cb *callback, void *user_data)
  99 {
 100         return _register_response_cb(provider, (void *)callback,
 101                         true, DATACONTROL_TYPE_MAP_GET, user_data);
 102 }
 103
 104 EXPORT_API int data_control_map_unbind_response_cb(data_control_h provider)
 105 {
 106         return _unregister_response_cb(provider, true, DATACONTROL_TYPE_MAP_GET);
 107 }
 108
 109 EXPORT_API int data_control_map_bind_add_bulk_data_response_cb(
 110                 data_control_h provider,
 111                 data_control_bulk_cb callback,
 112                 void *user_data)
 113 {
 114         return _register_response_cb(provider, (void *)callback,
 115                         true, DATACONTROL_TYPE_MAP_BULK_ADD, user_data);
 116 }
 117
 118 EXPORT_API int data_control_map_unbind_add_bulk_data_response_cb(
 119                 data_control_h provider)
 120 {
 121         return _unregister_response_cb(provider, true,
 122                         DATACONTROL_TYPE_MAP_BULK_ADD);
 123 }
 124
 125 EXPORT_API int data_control_map_get(data_control_h provider,
 126                 const char *key, int *request_id)
 127 {
 128         int retval;
 129
 130         if (provider == NULL || provider->provider_id == NULL ||
 131                         provider->data_id == NULL || key == NULL) {
 132                 _LOGE("Invalid parameter");
 133                 return DATA_CONTROL_ERROR_INVALID_PARAMETER;
 134         }
 135
 136         retval = _check_privilege(PRIVILEGE_CONSUMER);
 137         if (retval != DATA_CONTROL_ERROR_NONE)
 138                 return retval;
 139
 140         retval = _check_cert(provider->provider_id, true, NULL);
 141         if (retval != DATA_CONTROL_ERROR_NONE)
 142                 return retval;
 143
 144         return data_control_map_get_with_page(provider, key, request_id, 1, 20);
 145 }
 146
 147 EXPORT_API int data_control_map_get_with_page(data_control_h provider,
 148                 const char *key, int *request_id, int page_number, int count_per_page)
 149 {
 150         unsigned int arg_size;
 151         int ret = 0;
 152         const char *arg_list[4];
 153         char page_no_str[32];
 154         char count_per_page_str[32];
 155         char handle_id[MAX_LEN_DATACONTROL_HANDLE_ID] = {0, };
 156         int reqId;
 157
 158         if (provider == NULL || provider->provider_id == NULL ||
 159                         provider->data_id == NULL ||
 160                         key == NULL || page_number < 1) {
 161                 _LOGE("Invalid parameter");
 162                 return DATA_CONTROL_ERROR_INVALID_PARAMETER;
 163         }
 164
 165         ret = _check_privilege(PRIVILEGE_CONSUMER);
 166         if (ret != DATA_CONTROL_ERROR_NONE)
 167                 return ret;
 168
 169         ret = _check_cert(provider->provider_id, true, NULL);
 170         if (ret != DATA_CONTROL_ERROR_NONE)
 171                 return ret;
 172
 173         _LOGI("Gets the value list from provider_id: %s, data_id: %s",
 174                         provider->provider_id, provider->data_id);
 175
 176         arg_size = (strlen(provider->data_id) + strlen(key)) * sizeof(wchar_t);
 177         if (arg_size > MAX_REQUEST_ARGUMENT_SIZE) {
 178                 _LOGE("The size of sending argument (%u) exceeds the maximum limit.",
 179                                 arg_size);
 180                 return DATA_CONTROL_ERROR_MAX_EXCEEDED;
 181         }
 182
 183         bundle *b = bundle_create();
 184         if (!b) {
 185                 _LOGE("unable to create bundle: %d", errno);
 186                 return DATA_CONTROL_ERROR_INVALID_PARAMETER;
 187         }
 188
 189         bundle_add_str(b, OSP_K_DATACONTROL_PROVIDER, provider->provider_id);
 190         bundle_add_str(b, OSP_K_DATACONTROL_DATA, provider->data_id);
 191         snprintf(handle_id, MAX_LEN_DATACONTROL_HANDLE_ID, "%u",
 192                         provider->handle_id);
 193         bundle_add_str(b, OSP_K_DATACONTROL_HANDLE_ID, handle_id);
 194
 195         arg_list[0] = provider->data_id;
 196         arg_list[1] = key;
 197
 198         ret = snprintf(page_no_str, sizeof(page_no_str), "%d", page_number);
 199         if (ret < 0) {
 200                 _LOGE("unable to convert page no to string: %d", errno);
 201                 bundle_free(b);
 202                 return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
 203         }
 204
 205         ret = snprintf(count_per_page_str, sizeof(count_per_page_str),
 206                         "%d", count_per_page);
 207         if (ret < 0) {
 208                 _LOGE("unable to convert count per page no to string: %d", errno);
 209                 bundle_free(b);
 210                 return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
 211         }
 212
 213         arg_list[2] = page_no_str;
 214         arg_list[3] = count_per_page_str;
 215
 216         bundle_add_str_array(b, OSP_K_ARG, arg_list, 4);
 217
 218         /* Set the request id */
 219         reqId = _datacontrol_create_request_id();
 220         *request_id = reqId;
 221
 222         ret = _request_provider(provider, DATACONTROL_TYPE_MAP_GET, b, NULL, reqId);
 223         bundle_free(b);
 224
 225         return ret;
 226
 227 }
 228
 229 EXPORT_API int data_control_map_set(data_control_h provider, const char *key,
 230                 const char *old_value, const char *new_value, int *request_id)
 231 {
 232         int retval;
 233         unsigned int arg_size;
 234         bundle *b;
 235         const char *arg_list[4];
 236         char handle_id[MAX_LEN_DATACONTROL_HANDLE_ID] = {0, };
 237         int reqId;
 238
 239         if (provider == NULL || provider->provider_id == NULL ||
 240                         provider->data_id == NULL || key == NULL ||
 241                         old_value == NULL || new_value == NULL) {
 242                 _LOGE("Invalid parameter");
 243                 return DATA_CONTROL_ERROR_INVALID_PARAMETER;
 244         }
 245
 246         retval = _check_privilege(PRIVILEGE_CONSUMER);
 247         if (retval != DATA_CONTROL_ERROR_NONE)
 248                 return retval;
 249
 250         retval = _check_cert(provider->provider_id, true, NULL);
 251         if (retval != DATA_CONTROL_ERROR_NONE)
 252                 return retval;
 253
 254         _LOGI("Sets the old value to new value in provider_id: %s, data_id: %s",
 255                         provider->provider_id, provider->data_id);
 256
 257         arg_size = (strlen(provider->data_id) + strlen(key) +
 258                         strlen(old_value) + strlen(new_value)) * sizeof(wchar_t);
 259         if (arg_size > MAX_REQUEST_ARGUMENT_SIZE) {
 260                 _LOGE("The size of sending argument (%u) exceeds the maximum limit.",
 261                                 arg_size);
 262                 return DATA_CONTROL_ERROR_MAX_EXCEEDED;
 263         }
 264
 265         b = bundle_create();
 266         if (!b) {
 267                 _LOGE("unable to create bundle: %d", errno);
 268                 return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
 269         }
 270
 271         bundle_add_str(b, OSP_K_DATACONTROL_PROVIDER, provider->provider_id);
 272         bundle_add_str(b, OSP_K_DATACONTROL_DATA, provider->data_id);
 273         snprintf(handle_id, MAX_LEN_DATACONTROL_HANDLE_ID, "%u",
 274                         provider->handle_id);
 275         bundle_add_str(b, OSP_K_DATACONTROL_HANDLE_ID, handle_id);
 276
 277         arg_list[0] = provider->data_id;
 278         arg_list[1] = key;
 279         arg_list[2] = old_value;
 280         arg_list[3] = new_value;
 281
 282         bundle_add_str_array(b, OSP_K_ARG, arg_list, 4);
 283
 284         /* Set the request id */
 285         reqId = _datacontrol_create_request_id();
 286         *request_id = reqId;
 287
 288         retval =
 289                 _request_provider(provider, DATACONTROL_TYPE_MAP_SET, b, NULL, reqId);
 290         bundle_free(b);
 291
 292         return retval;
 293 }
 294
 295 EXPORT_API int data_control_map_add(data_control_h provider,
 296                 const char *key, const char *value, int *request_id)
 297 {
 298         int retval;
 299         unsigned int arg_size;
 300         bundle *b;
 301         const char *arg_list[3];
 302         char handle_id[MAX_LEN_DATACONTROL_HANDLE_ID] = {0, };
 303         int reqId;
 304
 305         if (provider == NULL || provider->provider_id == NULL ||
 306                         provider->data_id == NULL || key == NULL || value == NULL) {
 307                 _LOGE("Invalid parameter");
 308                 return DATA_CONTROL_ERROR_INVALID_PARAMETER;
 309         }
 310
 311         retval = _check_privilege(PRIVILEGE_CONSUMER);
 312         if (retval != DATA_CONTROL_ERROR_NONE)
 313                 return retval;
 314
 315         retval = _check_cert(provider->provider_id, true, NULL);
 316         if (retval != DATA_CONTROL_ERROR_NONE)
 317                 return retval;
 318
 319         _LOGI("Adds the value in provider_id: %s, data_id: %s",
 320                         provider->provider_id, provider->data_id);
 321
 322         arg_size = (strlen(provider->data_id) + strlen(key) +
 323                         strlen(value)) * sizeof(wchar_t);
 324         if (arg_size > MAX_REQUEST_ARGUMENT_SIZE) {
 325                 _LOGE("The size of sending argument (%u) exceeds the maximum limit.",
 326                                 arg_size);
 327                 return DATA_CONTROL_ERROR_MAX_EXCEEDED;
 328         }
 329
 330         b = bundle_create();
 331         if (!b) {
 332                 _LOGE("unable to create bundle: %d", errno);
 333                 return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
 334         }
 335
 336         bundle_add_str(b, OSP_K_DATACONTROL_PROVIDER, provider->provider_id);
 337         bundle_add_str(b, OSP_K_DATACONTROL_DATA, provider->data_id);
 338         snprintf(handle_id, MAX_LEN_DATACONTROL_HANDLE_ID, "%u",
 339                         provider->handle_id);
 340         bundle_add_str(b, OSP_K_DATACONTROL_HANDLE_ID, handle_id);
 341
 342         arg_list[0] = provider->data_id;
 343         arg_list[1] = key;
 344         arg_list[2] = value;
 345
 346         bundle_add_str_array(b, OSP_K_ARG, arg_list, 3);
 347
 348         /* Set the request id */
 349         reqId = _datacontrol_create_request_id();
 350         *request_id = reqId;
 351
 352         retval =
 353                 _request_provider(provider, DATACONTROL_TYPE_MAP_ADD, b, NULL, reqId);
 354         bundle_free(b);
 355
 356         return retval;
 357 }
 358
 359 EXPORT_API int data_control_map_remove(data_control_h provider,
 360                 const char *key, const char *value, int *request_id)
 361 {
 362         int retval;
 363         unsigned int arg_size;
 364         bundle *b;
 365         const char *arg_list[3];
 366         char handle_id[MAX_LEN_DATACONTROL_HANDLE_ID] = {0, };
 367         int reqId;
 368
 369         if (provider == NULL || provider->provider_id == NULL ||
 370                         provider->data_id == NULL || key == NULL || value == NULL) {
 371                 _LOGE("Invalid parameter");
 372                 return DATA_CONTROL_ERROR_INVALID_PARAMETER;
 373         }
 374
 375         retval = _check_privilege(PRIVILEGE_CONSUMER);
 376         if (retval != DATA_CONTROL_ERROR_NONE)
 377                 return retval;
 378
 379         retval = _check_cert(provider->provider_id, true, NULL);
 380         if (retval != DATA_CONTROL_ERROR_NONE)
 381                 return retval;
 382
 383         _LOGI("Removes the value in provider_id: %s, data_id: %s",
 384                         provider->provider_id, provider->data_id);
 385
 386         arg_size = (strlen(provider->data_id) + strlen(key) +
 387                         strlen(value)) * sizeof(wchar_t);
 388         if (arg_size > MAX_REQUEST_ARGUMENT_SIZE) {
 389                 _LOGE("The size of sending argument (%u) exceeds the maximum limit.",
 390                                 arg_size);
 391                 return DATA_CONTROL_ERROR_MAX_EXCEEDED;
 392         }
 393
 394         b = bundle_create();
 395         if (!b) {
 396                 _LOGE("unable to create bundle: %d", errno);
 397                 return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
 398         }
 399
 400         bundle_add_str(b, OSP_K_DATACONTROL_PROVIDER, provider->provider_id);
 401         bundle_add_str(b, OSP_K_DATACONTROL_DATA, provider->data_id);
 402         snprintf(handle_id, MAX_LEN_DATACONTROL_HANDLE_ID, "%u",
 403                         provider->handle_id);
 404         bundle_add_str(b, OSP_K_DATACONTROL_HANDLE_ID, handle_id);
 405
 406         arg_list[0] = provider->data_id;
 407         arg_list[1] = key;
 408         arg_list[2] = value;
 409
 410         bundle_add_str_array(b, OSP_K_ARG, arg_list, 3);
 411
 412         /* Set the request id */
 413         reqId = _datacontrol_create_request_id();
 414         *request_id = reqId;
 415
 416         retval =
 417                 _request_provider(provider, DATACONTROL_TYPE_MAP_REMOVE, b, NULL, reqId);
 418         bundle_free(b);
 419
 420         return retval;
 421 }
 422
 423 EXPORT_API int data_control_map_add_bulk_data(data_control_h provider,
 424                 data_control_bulk_data_h bulk_data_h, int *request_id)
 425 {
 426         int retval;
 427         long long arg_size = 0;
 428         bundle *b;
 429         bundle *data;
 430         const char *arg_list[3];
 431         char handle_id[MAX_LEN_DATACONTROL_HANDLE_ID] = {0, };
 432         int count;
 433         int i;
 434
 435         if (provider == NULL || provider->provider_id == NULL ||
 436                         provider->data_id == NULL) {
 437                 _LOGE("Invalid parameter");
 438                 return DATA_CONTROL_ERROR_INVALID_PARAMETER;
 439         }
 440
 441         retval = _check_privilege(PRIVILEGE_CONSUMER);
 442         if (retval != DATA_CONTROL_ERROR_NONE)
 443                 return retval;
 444
 445         retval = _check_cert(provider->provider_id, true, NULL);
 446         if (retval != DATA_CONTROL_ERROR_NONE)
 447                 return retval;
 448
 449         _LOGI("Adds the value in provider_id: %s, data_id: %s",
 450                         provider->provider_id, provider->data_id);
 451         data_control_bulk_data_get_count(bulk_data_h, &count);
 452         for (i = 0; i < count; i++) {
 453                 data_control_bulk_data_get_data(bulk_data_h, i, &data);
 454                 bundle_foreach(data, _bundle_foreach_check_arg_size_cb, &arg_size);
 455         }
 456
 457         arg_size +=
 458                 (strlen(provider->data_id) + strlen(provider->provider_id)) * sizeof(char);
 459         if (arg_size > MAX_REQUEST_ARGUMENT_SIZE) {
 460                 _LOGE("The size of sending argument (%lld) exceeds the maximum limit.",
 461                                 arg_size);
 462                 return DATA_CONTROL_ERROR_MAX_EXCEEDED;
 463         }
 464
 465         b = bundle_create();
 466         if (!b) {
 467                 _LOGE("unable to create bundle: %d", errno);
 468                 return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
 469         }
 470
 471         bundle_add_str(b, OSP_K_DATACONTROL_PROVIDER, provider->provider_id);
 472         bundle_add_str(b, OSP_K_DATACONTROL_DATA, provider->data_id);
 473
 474         snprintf(handle_id, MAX_LEN_DATACONTROL_HANDLE_ID, "%u",
 475                         provider->handle_id);
 476         bundle_add_str(b, OSP_K_DATACONTROL_HANDLE_ID, handle_id);
 477
 478         arg_list[0] = provider->data_id;
 479
 480         bundle_add_str_array(b, OSP_K_ARG, arg_list, 1);
 481         *request_id = _datacontrol_create_request_id();
 482
 483         retval = _request_provider(provider, DATACONTROL_TYPE_MAP_BULK_ADD, b,
 484                         bulk_data_h, *request_id);
 485         bundle_free(b);
 486
 487         return retval;
 488 }
 489