daemon/icd-ioty.c

   1 /*
   2  * Copyright (c) 2015 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 <stdio.h>
  18 #include <stdlib.h>
  19 #include <stdint.h> /* for uint8_t etc */
  20 #include <stdbool.h>
  21 #include <errno.h>
  22 #include <glib.h>
  23
  24 #include <octypes.h>
  25 #include <ocstack.h>
  26
  27 #include "iotcon.h"
  28 #include "ic-dbus.h"
  29 #include "ic-utils.h"
  30 #include "icd.h"
  31 #include "icd-payload.h"
  32 #include "icd-dbus.h"
  33 #include "icd-ioty.h"
  34 #include "icd-ioty-type.h"
  35 #include "icd-ioty-ocprocess.h"
  36
  37 static GMutex icd_csdk_mutex;
  38
  39 void icd_ioty_csdk_lock()
  40 {
  41         g_mutex_lock(&icd_csdk_mutex);
  42 }
  43
  44
  45 void icd_ioty_csdk_unlock()
  46 {
  47         g_mutex_unlock(&icd_csdk_mutex);
  48 }
  49
  50
  51 GThread* icd_ioty_init(const char *addr, unsigned short port)
  52 {
  53         FN_CALL;
  54         GError *error;
  55         GThread *thread;
  56
  57         OCStackResult result = OCInit(addr, port, OC_CLIENT_SERVER);
  58         if (OC_STACK_OK != result) {
  59                 ERR("OCInit() Fail(%d)", result);
  60                 return NULL;
  61         }
  62
  63         DBG("OCInit() Success");
  64
  65         thread = g_thread_try_new("packet_receive_thread", icd_ioty_ocprocess_thread,
  66                         NULL, &error);
  67         if (NULL == thread) {
  68                 ERR("g_thread_try_new() Fail(%s)", error->message);
  69                 g_error_free(error);
  70                 return NULL;
  71         }
  72
  73         return thread;
  74 }
  75
  76
  77 void icd_ioty_deinit(GThread *thread)
  78 {
  79         OCStackResult result;
  80
  81         icd_ioty_ocprocess_stop();
  82         g_thread_join(thread);
  83
  84         result = OCStop();
  85         if (OC_STACK_OK != result)
  86                 ERR("OCStop() Fail(%d)", result);
  87 }
  88
  89
  90 OCResourceHandle icd_ioty_register_resource(const char *uri_path,
  91                 const char* const* res_types, int ifaces, uint8_t properties)
  92 {
  93         FN_CALL;
  94         int i;
  95         OCStackResult ret;
  96         OCResourceHandle handle;
  97         const char *res_iface = NULL;
  98
  99         if (IOTCON_INTERFACE_DEFAULT & ifaces) {
 100                 res_iface = IC_INTERFACE_DEFAULT;
 101                 ifaces ^= IOTCON_INTERFACE_DEFAULT;
 102         } else if (IOTCON_INTERFACE_LINK & ifaces) {
 103                 res_iface = IC_INTERFACE_LINK;
 104                 ifaces ^= IOTCON_INTERFACE_LINK;
 105         } else if (IOTCON_INTERFACE_BATCH & ifaces) {
 106                 res_iface = IC_INTERFACE_BATCH;
 107                 ifaces ^= IOTCON_INTERFACE_BATCH;
 108         } else if (IOTCON_INTERFACE_GROUP & ifaces) {
 109                 res_iface = IC_INTERFACE_GROUP;
 110                 ifaces ^= IOTCON_INTERFACE_GROUP;
 111         } else {
 112                 ERR("Invalid interface type(%d)", ifaces);
 113                 return NULL;
 114         }
 115
 116         /* Secure option is not supported yet. */
 117         properties = (properties & OC_SECURE)? (properties ^ OC_SECURE):properties;
 118
 119         icd_ioty_csdk_lock();
 120         ret = OCCreateResource(&handle, res_types[0], res_iface, uri_path,
 121                         icd_ioty_ocprocess_req_handler, NULL, properties);
 122         icd_ioty_csdk_unlock();
 123         if (OC_STACK_OK != ret) {
 124                 ERR("OCCreateResource() Fail(%d)", ret);
 125                 return NULL;
 126         }
 127
 128         for (i = 1; res_types[i]; i++)
 129                 icd_ioty_bind_type(handle, res_types[i]);
 130
 131         if (IOTCON_INTERFACE_DEFAULT & ifaces)
 132                 icd_ioty_bind_interface(handle, IOTCON_INTERFACE_DEFAULT);
 133         if (IOTCON_INTERFACE_LINK & ifaces)
 134                 icd_ioty_bind_interface(handle, IOTCON_INTERFACE_LINK);
 135         if (IOTCON_INTERFACE_BATCH & ifaces)
 136                 icd_ioty_bind_interface(handle, IOTCON_INTERFACE_BATCH);
 137         if (IOTCON_INTERFACE_GROUP & ifaces)
 138                 icd_ioty_bind_interface(handle, IOTCON_INTERFACE_GROUP);
 139
 140         return handle;
 141 }
 142
 143
 144 int icd_ioty_unregister_resource(OCResourceHandle handle)
 145 {
 146         OCStackResult ret;
 147
 148         icd_ioty_csdk_lock();
 149         ret = OCDeleteResource(handle);
 150         icd_ioty_csdk_unlock();
 151         if (OC_STACK_OK != ret) {
 152                 ERR("OCDeleteResource() Fail(%d)", ret);
 153                 return IOTCON_ERROR_IOTIVITY;
 154         }
 155
 156         return IOTCON_ERROR_NONE;
 157 }
 158
 159
 160 int icd_ioty_bind_interface(OCResourceHandle handle, iotcon_interface_e iface)
 161 {
 162         int ret;
 163         OCStackResult result;
 164         char *resource_interface;
 165
 166         ret = ic_utils_convert_interface_flag(iface, &resource_interface);
 167         if (IOTCON_ERROR_NONE != ret) {
 168                 ERR("ic_utils_convert_interface_flag(%d) Fail(%d)", iface, ret);
 169                 return ret;
 170         }
 171
 172         icd_ioty_csdk_lock();
 173         result = OCBindResourceInterfaceToResource(handle, resource_interface);
 174         icd_ioty_csdk_unlock();
 175         if (OC_STACK_OK != result) {
 176                 ERR("OCBindResourceInterfaceToResource() Fail(%d)", result);
 177                 return IOTCON_ERROR_IOTIVITY;
 178         }
 179
 180         return IOTCON_ERROR_NONE;
 181 }
 182
 183
 184 int icd_ioty_bind_type(OCResourceHandle handle, const char *resource_type)
 185 {
 186         OCStackResult ret;
 187
 188         icd_ioty_csdk_lock();
 189         ret = OCBindResourceTypeToResource(handle, resource_type);
 190         icd_ioty_csdk_unlock();
 191         if (OC_STACK_OK != ret) {
 192                 ERR("OCBindResourceTypeToResource() Fail(%d)", ret);
 193                 return IOTCON_ERROR_IOTIVITY;
 194         }
 195
 196         return IOTCON_ERROR_NONE;
 197 }
 198
 199
 200 int icd_ioty_bind_resource(OCResourceHandle parent, OCResourceHandle child)
 201 {
 202         OCStackResult ret;
 203
 204         icd_ioty_csdk_lock();
 205         ret = OCBindResource(parent, child);
 206         icd_ioty_csdk_unlock();
 207         if (OC_STACK_OK != ret) {
 208                 ERR("OCBindResource() Fail(%d)", ret);
 209                 return IOTCON_ERROR_IOTIVITY;
 210         }
 211
 212         return IOTCON_ERROR_NONE;
 213 }
 214
 215
 216 int icd_ioty_unbind_resource(OCResourceHandle parent, OCResourceHandle child)
 217 {
 218         OCStackResult ret;
 219
 220         icd_ioty_csdk_lock();
 221         ret = OCUnBindResource(parent, child);
 222         icd_ioty_csdk_unlock();
 223         if (OC_STACK_OK != ret) {
 224                 ERR("OCUnBindResource() Fail(%d)", ret);
 225                 return IOTCON_ERROR_IOTIVITY;
 226         }
 227
 228         return IOTCON_ERROR_NONE;
 229 }
 230
 231
 232 int icd_ioty_notify_list_of_observers(OCResourceHandle handle, GVariant *msg,
 233                 GVariant *observers)
 234 {
 235         int i, error_code, obs_length;
 236         GVariant *repr_gvar;
 237         GVariantIter obs_iter, msg_iter;
 238         OCStackResult ret;
 239         OCRepPayload *payload;
 240
 241         g_variant_iter_init(&obs_iter, observers);
 242         obs_length = g_variant_iter_n_children(&obs_iter);
 243
 244         /* Variable-length Array */
 245         OCObservationId obs_ids[obs_length];
 246
 247         for (i = 0; i < obs_length; i++)
 248                 g_variant_iter_loop(&obs_iter, "i", &obs_ids[i]);
 249
 250         g_variant_iter_init(&msg_iter, msg);
 251         g_variant_iter_loop(&msg_iter, "(iv)", &error_code, &repr_gvar);
 252         /* TODO : How to use error_code. */
 253
 254         payload = icd_payload_repr_from_gvariant(repr_gvar);
 255
 256         icd_ioty_csdk_lock();
 257         /* TODO : QoS is come from lib. */
 258         ret = OCNotifyListOfObservers(handle, obs_ids, obs_length, payload, OC_LOW_QOS);
 259         icd_ioty_csdk_unlock();
 260
 261         if (OC_STACK_NO_OBSERVERS == ret) {
 262                 WARN("No Observers. Stop Notifying");
 263                 return IOTCON_ERROR_NONE;
 264         } else if (OC_STACK_OK != ret) {
 265                 ERR("OCNotifyListOfObservers() Fail(%d)", ret);
 266                 return IOTCON_ERROR_IOTIVITY;
 267         }
 268
 269         return IOTCON_ERROR_NONE;
 270 }
 271
 272
 273 int icd_ioty_notify_all(OCResourceHandle handle)
 274 {
 275         OCStackResult ret;
 276
 277         icd_ioty_csdk_lock();
 278         /* TODO : QoS is come from lib. */
 279         ret = OCNotifyAllObservers(handle, OC_LOW_QOS);
 280         icd_ioty_csdk_unlock();
 281
 282         if (OC_STACK_NO_OBSERVERS == ret) {
 283                 WARN("No Observers. Stop Notifying");
 284                 return IOTCON_ERROR_NONE;
 285         } else if (OC_STACK_OK != ret) {
 286                 ERR("OCNotifyAllObservers() Fail(%d)", ret);
 287                 return IOTCON_ERROR_IOTIVITY;
 288         }
 289
 290         return IOTCON_ERROR_NONE;
 291 }
 292
 293
 294 static int _ioty_get_header_options(GVariantIter *src, int src_size,
 295                 OCHeaderOption dest[], int dest_size)
 296 {
 297         int i = 0;
 298         char *option_data;
 299         unsigned short option_id;
 300
 301         RETV_IF(NULL == dest, IOTCON_ERROR_INVALID_PARAMETER);
 302
 303         if (dest_size < src_size) {
 304                 ERR("Exceed Size(%d)", src_size);
 305                 return IOTCON_ERROR_INVALID_PARAMETER;
 306         }
 307
 308         while (g_variant_iter_loop(src, "(q&s)", &option_id, &option_data)) {
 309                 dest[i].protocolID = OC_COAP_ID;
 310                 dest[i].optionID = option_id;
 311                 dest[i].optionLength = strlen(option_data) + 1;
 312                 memcpy(dest[i].optionData, option_data, dest[i].optionLength);
 313                 i++;
 314         }
 315
 316         return IOTCON_ERROR_NONE;
 317 }
 318
 319
 320 int icd_ioty_send_response(GVariant *resp)
 321 {
 322         int result, error_code, options_size;
 323         int request_handle, resource_handle;
 324         char *new_uri_path;
 325         GVariant *repr_gvar;
 326         GVariantIter *options;
 327         OCStackResult ret;
 328         OCEntityHandlerResponse response = {0};
 329
 330         g_variant_get(resp, "(&sia(qs)ivii)",
 331                         &new_uri_path,
 332                         &error_code,
 333                         &options,
 334                         &result,
 335                         &repr_gvar,
 336                         &request_handle,
 337                         &resource_handle);
 338
 339         response.requestHandle = GINT_TO_POINTER(request_handle);
 340         response.resourceHandle = GINT_TO_POINTER(resource_handle);
 341         response.ehResult = (OCEntityHandlerResult)result;
 342
 343         if (OC_EH_RESOURCE_CREATED == response.ehResult)
 344                 snprintf(response.resourceUri, sizeof(response.resourceUri), "%s", new_uri_path);
 345
 346         options_size = g_variant_iter_n_children(options);
 347         response.numSendVendorSpecificHeaderOptions = options_size;
 348
 349         if (0 != options_size) {
 350                 int ret= _ioty_get_header_options(options,
 351                                 response.numSendVendorSpecificHeaderOptions,
 352                                 response.sendVendorSpecificHeaderOptions,
 353                                 sizeof(response.sendVendorSpecificHeaderOptions)
 354                                 / sizeof(response.sendVendorSpecificHeaderOptions[0]));
 355
 356                 if (IOTCON_ERROR_NONE != ret)
 357                         ERR("_ioty_get_header_options() Fail(%d)", ret);
 358         }
 359         g_variant_iter_free(options);
 360
 361         response.payload = (OCPayload*)icd_payload_repr_from_gvariant(repr_gvar);
 362
 363         /* related to block transfer */
 364         response.persistentBufferFlag = 0;
 365
 366         icd_ioty_csdk_lock();
 367         ret = OCDoResponse(&response);
 368         icd_ioty_csdk_unlock();
 369
 370         if (OC_STACK_OK != ret) {
 371                 ERR("OCDoResponse() Fail(%d)", ret);
 372                 return IOTCON_ERROR_IOTIVITY;
 373         }
 374
 375         return IOTCON_ERROR_NONE;
 376 }
 377
 378
 379 static void _ioty_free_signal_context(void *data)
 380 {
 381         icd_sig_ctx_s *context = data;
 382         free(context->bus_name);
 383         free(context);
 384 }
 385
 386
 387 int icd_ioty_find_resource(const char *host_address, const char *resource_type,
 388                 unsigned int signum, const char *bus_name)
 389 {
 390         int len;
 391         OCStackResult result;
 392         icd_sig_ctx_s *context;
 393         char uri[PATH_MAX] = {0};
 394         OCCallbackData cbdata = {0};
 395         OCConnectivityType oic_conn_type;
 396         iotcon_connectivity_type_e conn_type = IOTCON_CONNECTIVITY_IPV4;
 397
 398         if (IC_STR_EQUAL == strcmp(IOTCON_MULTICAST_ADDRESS, host_address)) {
 399                 len = snprintf(uri, sizeof(uri), "%s", OC_RSRVD_WELL_KNOWN_URI);
 400         } else {
 401                 len = snprintf(uri, sizeof(uri), ICD_IOTY_COAP"%s%s", host_address,
 402                                 OC_RSRVD_WELL_KNOWN_URI);
 403         }
 404         if (len <= 0 || sizeof(uri) <= len) {
 405                 ERR("snprintf() Fail(%d)", len);
 406                 return IOTCON_ERROR_UNKNOWN;
 407         }
 408
 409         if (IC_STR_EQUAL != strcmp(IC_STR_NULL, resource_type))
 410                 snprintf(uri + len, sizeof(uri), "?rt=%s", resource_type);
 411
 412         context = calloc(1, sizeof(icd_sig_ctx_s));
 413         if (NULL == context) {
 414                 ERR("calloc() Fail(%d)", errno);
 415                 return IOTCON_ERROR_OUT_OF_MEMORY;
 416         }
 417
 418         context->bus_name = ic_utils_strdup(bus_name);
 419         context->signum = signum;
 420
 421         cbdata.context = context;
 422         cbdata.cb = icd_ioty_ocprocess_find_cb;
 423         cbdata.cd = _ioty_free_signal_context;
 424
 425         oic_conn_type = icd_ioty_conn_type_to_oic_conn_type(conn_type);
 426
 427         icd_ioty_csdk_lock();
 428         /* TODO : QoS is come from lib. */
 429         result = OCDoResource(NULL, OC_REST_DISCOVER, uri, NULL, NULL, oic_conn_type,
 430                         OC_LOW_QOS, &cbdata, NULL, 0);
 431         icd_ioty_csdk_unlock();
 432
 433         if (OC_STACK_OK != result) {
 434                 ERR("OCDoResource() Fail(%d)", result);
 435                 free(context->bus_name);
 436                 free(context);
 437                 return IOTCON_ERROR_IOTIVITY;
 438         }
 439
 440         return IOTCON_ERROR_NONE;
 441 }
 442
 443
 444 /*
 445  * returned string SHOULD be released by you
 446  */
 447 static char* _icd_ioty_resource_generate_uri(char *host, bool is_secure, char *uri_path,
 448                 GVariant *query)
 449 {
 450         int len;
 451         bool loop_first = true;
 452         char *key, *value;
 453         GVariantIter query_iter;
 454         char uri_buf[PATH_MAX] = {0};
 455
 456         if (is_secure)
 457                 len = snprintf(uri_buf, sizeof(uri_buf), ICD_IOTY_COAPS"%s%s", host, uri_path);
 458         else
 459                 len = snprintf(uri_buf, sizeof(uri_buf), ICD_IOTY_COAP"%s%s", host, uri_path);
 460
 461         /* remove suffix '/' */
 462         if ('/' == uri_buf[strlen(uri_buf) - 1]) {
 463                 uri_buf[strlen(uri_buf) - 1] = '\0';
 464                 len--;
 465         }
 466
 467         g_variant_iter_init(&query_iter, query);
 468
 469         while (g_variant_iter_loop(&query_iter, "(&s&s)", &key, &value)) {
 470                 int query_len;
 471
 472                 DBG("query exist. key(%s), value(%s)", key, value);
 473
 474                 if (true == loop_first) {
 475                         query_len = snprintf(uri_buf + len, sizeof(uri_buf), "?%s=%s", key, value);
 476                         loop_first = false;
 477                 } else {
 478                         query_len = snprintf(uri_buf + len, sizeof(uri_buf), "&%s=%s", key, value);
 479                 }
 480
 481                 len += query_len;
 482         }
 483
 484         return strdup(uri_buf);
 485 }
 486
 487
 488 void icd_ioty_complete(int type, GDBusMethodInvocation *invocation, GVariant *value)
 489 {
 490         switch(type) {
 491         case ICD_CRUD_GET:
 492                 ic_dbus_complete_get(icd_dbus_get_object(), invocation, value);
 493                 break;
 494         case ICD_CRUD_PUT:
 495                 ic_dbus_complete_put(icd_dbus_get_object(), invocation, value);
 496                 break;
 497         case ICD_CRUD_POST:
 498                 ic_dbus_complete_post(icd_dbus_get_object(), invocation, value);
 499                 break;
 500         case ICD_CRUD_DELETE:
 501                 ic_dbus_complete_delete(icd_dbus_get_object(), invocation, value);
 502                 break;
 503         }
 504 }
 505
 506
 507 void icd_ioty_complete_error(int type, GDBusMethodInvocation *invocation, int ret_val)
 508 {
 509         GVariant *value;
 510
 511         switch (type) {
 512         case ICD_CRUD_GET:
 513                 value = g_variant_new("(a(qs)vi)", NULL, NULL, ret_val);
 514                 ic_dbus_complete_get(icd_dbus_get_object(), invocation, value);
 515                 break;
 516         case ICD_CRUD_PUT:
 517                 value = g_variant_new("(a(qs)vi)", NULL, NULL, ret_val);
 518                 ic_dbus_complete_put(icd_dbus_get_object(), invocation, value);
 519                 break;
 520         case ICD_CRUD_POST:
 521                 value = g_variant_new("(a(qs)vi)", NULL, NULL, ret_val);
 522                 ic_dbus_complete_post(icd_dbus_get_object(), invocation, value);
 523                 break;
 524         case ICD_CRUD_DELETE:
 525                 value = g_variant_new("(a(qs)i)", NULL, ret_val);
 526                 ic_dbus_complete_delete(icd_dbus_get_object(), invocation, value);
 527                 break;
 528         }
 529 }
 530
 531
 532 static gboolean _icd_ioty_crud(int type, icDbus *object, GDBusMethodInvocation *invocation,
 533                 GVariant *resource, GVariant *query, GVariant *repr)
 534 {
 535         bool is_secure;
 536         OCMethod rest_type;
 537         OCStackResult result;
 538         GVariantIter *options;
 539         OCCallbackData cbdata = {0};
 540         int conn_type, options_size;
 541         char *uri_path, *host, *uri;
 542         char uri_buf[PATH_MAX] = {0};
 543         OCHeaderOption oic_options[MAX_HEADER_OPTIONS];
 544         OCHeaderOption *oic_options_ptr = NULL;
 545         OCPayload *payload = NULL;
 546         OCConnectivityType oic_conn_type;
 547
 548         switch (type) {
 549         case ICD_CRUD_GET:
 550                 cbdata.cb = icd_ioty_ocprocess_get_cb;
 551                 rest_type = OC_REST_GET;
 552                 break;
 553         case ICD_CRUD_PUT:
 554                 cbdata.cb = icd_ioty_ocprocess_put_cb;
 555                 rest_type = OC_REST_PUT;
 556                 break;
 557         case ICD_CRUD_POST:
 558                 cbdata.cb = icd_ioty_ocprocess_post_cb;
 559                 rest_type = OC_REST_POST;
 560                 break;
 561         case ICD_CRUD_DELETE:
 562                 cbdata.cb = icd_ioty_ocprocess_delete_cb;
 563                 rest_type = OC_REST_DELETE;
 564                 break;
 565         default:
 566                 ERR("Invalid CRUD Type(%d)", type);
 567                 return FALSE;
 568         }
 569
 570         g_variant_get(resource, "(&s&sba(qs)i)", &uri_path, &host, &is_secure,  &options,
 571                         &conn_type);
 572
 573         switch (type) {
 574         case ICD_CRUD_GET:
 575         case ICD_CRUD_PUT:
 576         case ICD_CRUD_POST:
 577                 uri = _icd_ioty_resource_generate_uri(host, is_secure, uri_path, query);
 578                 if (NULL == uri) {
 579                         ERR("_icd_ioty_resource_generate_uri() Fail");
 580                         g_variant_iter_free(options);
 581                         icd_ioty_complete_error(type, invocation, IOTCON_ERROR_INVALID_PARAMETER);
 582                         return TRUE;
 583                 }
 584                 break;
 585         case ICD_CRUD_DELETE:
 586                 snprintf(uri_buf, sizeof(uri_buf), "%s%s", host, uri_path);
 587                 uri = strdup(uri_buf);
 588                 break;
 589         }
 590
 591         cbdata.context = invocation;
 592
 593         options_size = g_variant_iter_n_children(options);
 594         if (0 != options_size) {
 595                 int ret = _ioty_get_header_options(options, options_size, oic_options,
 596                                 sizeof(oic_options) / sizeof(oic_options[0]));
 597                 if (IOTCON_ERROR_NONE != ret) {
 598                         ERR("_ioty_get_header_options() Fail(%d)", ret);
 599                         free(uri);
 600                         g_variant_iter_free(options);
 601                         icd_ioty_complete_error(type, invocation, ret);
 602                         return TRUE;
 603                 }
 604                 oic_options_ptr = oic_options;
 605         }
 606         g_variant_iter_free(options);
 607
 608         if (repr)
 609                 payload = (OCPayload*)icd_payload_repr_from_gvariant(repr);
 610
 611         oic_conn_type = icd_ioty_conn_type_to_oic_conn_type(conn_type);
 612
 613         icd_ioty_csdk_lock();
 614         /* TODO : QoS is come from lib. And user can set QoS to client structure.  */
 615         result = OCDoResource(NULL, rest_type, uri, NULL, payload, oic_conn_type, OC_LOW_QOS,
 616                         &cbdata, oic_options_ptr, options_size);
 617         icd_ioty_csdk_unlock();
 618
 619         free(uri);
 620
 621         if (OC_STACK_OK != result) {
 622                 ERR("OCDoResource() Fail(%d)", result);
 623                 icd_ioty_complete_error(type, invocation, IOTCON_ERROR_IOTIVITY);
 624                 return TRUE;
 625         }
 626
 627         return TRUE;
 628 }
 629
 630 gboolean icd_ioty_get(icDbus *object, GDBusMethodInvocation *invocation,
 631                 GVariant *resource, GVariant *query)
 632 {
 633         return _icd_ioty_crud(ICD_CRUD_GET, object, invocation, resource, query, NULL);
 634 }
 635
 636
 637 gboolean icd_ioty_put(icDbus *object, GDBusMethodInvocation *invocation,
 638                 GVariant *resource, GVariant *repr, GVariant *query)
 639 {
 640         return _icd_ioty_crud(ICD_CRUD_PUT, object, invocation, resource, query, repr);
 641 }
 642
 643
 644 gboolean icd_ioty_post(icDbus *object, GDBusMethodInvocation *invocation,
 645                 GVariant *resource, GVariant *repr, GVariant *query)
 646 {
 647         return _icd_ioty_crud(ICD_CRUD_POST, object, invocation, resource, query, repr);
 648 }
 649
 650
 651 gboolean icd_ioty_delete(icDbus *object, GDBusMethodInvocation *invocation,
 652                 GVariant *resource)
 653 {
 654         return _icd_ioty_crud(ICD_CRUD_DELETE, object, invocation, resource, NULL, NULL);
 655 }
 656
 657
 658 OCDoHandle icd_ioty_observer_start(GVariant *resource, int observe_type, GVariant *query,
 659                 unsigned int signal_number, const char *bus_name)
 660 {
 661         bool is_secure;
 662         OCMethod method;
 663         OCDoHandle handle;
 664         OCStackResult result;
 665         GVariantIter *options;
 666         icd_sig_ctx_s *context;
 667         OCCallbackData cbdata = {0};
 668         int conn_type, options_size;
 669         char *uri_path, *host, *uri;
 670         OCHeaderOption oic_options[MAX_HEADER_OPTIONS];
 671         OCHeaderOption *oic_options_ptr = NULL;
 672         OCConnectivityType oic_conn_type;
 673
 674         g_variant_get(resource, "(&s&sba(qs)i)", &uri_path, &host, &is_secure,  &options,
 675                         &conn_type);
 676
 677         uri = _icd_ioty_resource_generate_uri(host, is_secure, uri_path, query);
 678         if (NULL == uri) {
 679                 ERR("_icd_ioty_resource_generate_uri() Fail");
 680                 g_variant_iter_free(options);
 681                 return NULL;
 682         }
 683
 684         if (IOTCON_OBSERVE == observe_type)
 685                 method = OC_REST_OBSERVE;
 686         else if (IOTCON_OBSERVE_ALL == observe_type)
 687                 method = OC_REST_OBSERVE_ALL;
 688         else
 689                 method = OC_REST_OBSERVE_ALL;
 690
 691         context = calloc(1, sizeof(icd_sig_ctx_s));
 692         if (NULL == context) {
 693                 ERR("calloc() Fail(%d)", errno);
 694                 return NULL;
 695         }
 696         context->bus_name = ic_utils_strdup(bus_name);
 697         context->signum = signal_number;
 698
 699         cbdata.context = context;
 700         cbdata.cb = icd_ioty_ocprocess_observe_cb;
 701         cbdata.cd = _ioty_free_signal_context;
 702
 703         options_size = g_variant_iter_n_children(options);
 704         if (0 != options_size) {
 705                 int ret = _ioty_get_header_options(options, options_size, oic_options,
 706                                 sizeof(oic_options) / sizeof(oic_options[0]));
 707                 if (IOTCON_ERROR_NONE != ret) {
 708                         ERR("_ioty_get_header_options() Fail(%d)", ret);
 709                         free(context->bus_name);
 710                         free(context);
 711                         free(uri);
 712                         g_variant_iter_free(options);
 713                         return NULL;
 714                 }
 715                 oic_options_ptr = oic_options;
 716         }
 717         g_variant_iter_free(options);
 718
 719         oic_conn_type = icd_ioty_conn_type_to_oic_conn_type(conn_type);
 720
 721         icd_ioty_csdk_lock();
 722         /* TODO : QoS is come from lib. And user can set QoS to client structure.  */
 723         result = OCDoResource(&handle, method, uri, NULL, NULL, oic_conn_type, OC_LOW_QOS,
 724                         &cbdata, oic_options_ptr, options_size);
 725         icd_ioty_csdk_unlock();
 726         free(uri);
 727         if (OC_STACK_OK != result) {
 728                 ERR("OCDoResource() Fail(%d)", result);
 729                 free(context->bus_name);
 730                 free(context);
 731                 return NULL;
 732         }
 733
 734         return handle;
 735 }
 736
 737
 738 int icd_ioty_observer_stop(OCDoHandle handle, GVariant *options)
 739 {
 740         int options_size;
 741         OCStackResult ret;
 742         GVariantIter options_iter;
 743         OCHeaderOption oic_options[MAX_HEADER_OPTIONS];
 744         OCHeaderOption *oic_options_ptr = NULL;
 745
 746         g_variant_iter_init(&options_iter, options);
 747
 748         options_size = g_variant_iter_n_children(&options_iter);
 749         if (0 != options_size) {
 750                 int ret = _ioty_get_header_options(&options_iter, options_size, oic_options,
 751                                 sizeof(oic_options) / sizeof(oic_options[0]));
 752                 if (IOTCON_ERROR_NONE != ret) {
 753                         ERR("_ioty_get_header_options() Fail(%d)", ret);
 754                         return ret;
 755                 }
 756                 oic_options_ptr = oic_options;
 757         }
 758
 759         icd_ioty_csdk_lock();
 760         ret = OCCancel(handle, OC_HIGH_QOS, oic_options_ptr, options_size);
 761         icd_ioty_csdk_unlock();
 762         if (OC_STACK_OK != ret) {
 763                 ERR("OCCancel() Fail(%d)", ret);
 764                 return IOTCON_ERROR_IOTIVITY;
 765         }
 766
 767         return IOTCON_ERROR_NONE;
 768 }
 769
 770
 771 int icd_ioty_register_device_info(GVariant *value)
 772 {
 773         OCStackResult result;
 774         OCDeviceInfo device_info = {0};
 775
 776         g_variant_get(value, "(&s)", &device_info.deviceName);
 777
 778         icd_ioty_csdk_lock();
 779         result = OCSetDeviceInfo(device_info);
 780         icd_ioty_csdk_unlock();
 781
 782         if (OC_STACK_OK != result) {
 783                 ERR("OCSetDeviceInfo() Fail(%d)", result);
 784                 return IOTCON_ERROR_IOTIVITY;
 785         }
 786
 787         return IOTCON_ERROR_NONE;
 788 }
 789
 790
 791 int icd_ioty_register_platform_info(GVariant *value)
 792 {
 793         OCStackResult result;
 794         OCPlatformInfo platform_info = {0};
 795
 796         g_variant_get(value, "(&s&s&s&s&s&s&s&s&s&s&s)",
 797                         &platform_info.platformID,
 798                         &platform_info.manufacturerName,
 799                         &platform_info.manufacturerUrl,
 800                         &platform_info.modelNumber,
 801                         &platform_info.dateOfManufacture,
 802                         &platform_info.platformVersion,
 803                         &platform_info.operatingSystemVersion,
 804                         &platform_info.hardwareVersion,
 805                         &platform_info.firmwareVersion,
 806                         &platform_info.supportUrl,
 807                         &platform_info.systemTime);
 808
 809         icd_ioty_csdk_lock();
 810         result = OCSetPlatformInfo(platform_info);
 811         icd_ioty_csdk_unlock();
 812
 813         if (OC_STACK_OK != result) {
 814                 ERR("OCSetPlatformInfo() Fail(%d)", result);
 815                 return IOTCON_ERROR_IOTIVITY;
 816         }
 817
 818         return IOTCON_ERROR_NONE;
 819 }
 820
 821
 822 int icd_ioty_get_info(int type, const char *host_address, unsigned int signal_number,
 823                 const char *bus_name)
 824 {
 825         OCStackResult result;
 826         icd_sig_ctx_s *context;
 827         OCCallbackData cbdata = {0};
 828         char uri[PATH_MAX] = {0};
 829         char *uri_path = NULL;
 830         iotcon_connectivity_type_e conn_type = IOTCON_CONNECTIVITY_IPV4;
 831         OCConnectivityType oic_conn_type;
 832
 833         if (ICD_DEVICE_INFO == type)
 834                 uri_path = OC_RSRVD_DEVICE_URI;
 835         else if (ICD_PLATFORM_INFO == type)
 836                 uri_path = OC_RSRVD_PLATFORM_URI;
 837         else
 838                 return IOTCON_ERROR_INVALID_PARAMETER;
 839
 840         if (IC_STR_EQUAL == strcmp(IOTCON_MULTICAST_ADDRESS, host_address))
 841                 snprintf(uri, sizeof(uri), "%s", uri_path);
 842         else
 843                 snprintf(uri, sizeof(uri), "%s%s", host_address, uri_path);
 844
 845         context = calloc(1, sizeof(icd_sig_ctx_s));
 846         if (NULL == context) {
 847                 ERR("calloc() Fail(%d)", errno);
 848                 return IOTCON_ERROR_OUT_OF_MEMORY;
 849         }
 850         context->bus_name = ic_utils_strdup(bus_name);
 851         context->signum = signal_number;
 852
 853         cbdata.context = context;
 854         cbdata.cb = icd_ioty_ocprocess_info_cb;
 855         cbdata.cd = _ioty_free_signal_context;
 856
 857         oic_conn_type = icd_ioty_conn_type_to_oic_conn_type(conn_type);
 858
 859         icd_ioty_csdk_lock();
 860         /* TODO : QoS is come from lib. And user can set QoS to client structure.  */
 861         result = OCDoResource(NULL, OC_REST_DISCOVER, uri, NULL, NULL, oic_conn_type,
 862                         OC_LOW_QOS, &cbdata, NULL, 0);
 863         icd_ioty_csdk_unlock();
 864
 865         if (OC_STACK_OK != result) {
 866                 ERR("OCDoResource() Fail(%d)", result);
 867                 free(context->bus_name);
 868                 free(context);
 869                 return IOTCON_ERROR_IOTIVITY;
 870         }
 871
 872         return IOTCON_ERROR_NONE;
 873 }
 874
 875
 876 OCDoHandle icd_ioty_subscribe_presence(const char *host_address,
 877                 const char *resource_type, unsigned int signal_number, const char *bus_name)
 878 {
 879         int len;
 880         OCDoHandle handle;
 881         OCStackResult result;
 882         char uri[PATH_MAX] = {0};
 883         OCCallbackData cbdata = {0};
 884         icd_sig_ctx_s *context;
 885         iotcon_connectivity_type_e conn_type = IOTCON_CONNECTIVITY_IPV4;
 886         OCConnectivityType oic_conn_type;
 887
 888         len = snprintf(uri, sizeof(uri), "%s%s", host_address, OC_RSRVD_PRESENCE_URI);
 889         if (len <= 0 || sizeof(uri) <= len) {
 890                 ERR("snprintf() Fail(%d)", len);
 891                 return NULL;
 892         }
 893
 894         if (IC_STR_EQUAL != strcmp(IC_STR_NULL, resource_type))
 895                 snprintf(uri + len, sizeof(uri), "?rt=%s", resource_type);
 896
 897         context = calloc(1, sizeof(icd_sig_ctx_s));
 898         if (NULL == context) {
 899                 ERR("calloc() Fail(%d)", errno);
 900                 return NULL;
 901         }
 902         context->bus_name = ic_utils_strdup(bus_name);
 903         context->signum = signal_number;
 904
 905         cbdata.context = context;
 906         cbdata.cb = icd_ioty_ocprocess_presence_cb;
 907         cbdata.cd = _ioty_free_signal_context;
 908
 909         oic_conn_type = icd_ioty_conn_type_to_oic_conn_type(conn_type);
 910
 911         icd_ioty_csdk_lock();
 912         result = OCDoResource(&handle, OC_REST_PRESENCE, uri, NULL, NULL, oic_conn_type,
 913                         OC_LOW_QOS, &cbdata, NULL, 0);
 914         icd_ioty_csdk_unlock();
 915
 916         if (OC_STACK_OK != result) {
 917                 ERR("OCDoResource() Fail(%d)", result);
 918                 free(context->bus_name);
 919                 free(context);
 920                 return NULL;
 921         }
 922         return handle;
 923 }
 924
 925
 926 int icd_ioty_unsubscribe_presence(OCDoHandle handle)
 927 {
 928         OCStackResult ret;
 929
 930         icd_ioty_csdk_lock();
 931         ret = OCCancel(handle, OC_LOW_QOS, NULL, 0);
 932         icd_ioty_csdk_unlock();
 933         if (OC_STACK_OK != ret) {
 934                 ERR("OCCancel() Fail(%d)", ret);
 935                 return IOTCON_ERROR_IOTIVITY;
 936         }
 937
 938         return IOTCON_ERROR_NONE;
 939 }
 940
 941
 942 int icd_ioty_start_presence(unsigned int time_to_live)
 943 {
 944         OCStackResult ret;
 945
 946         icd_ioty_csdk_lock();
 947         ret = OCStartPresence(time_to_live);
 948         icd_ioty_csdk_unlock();
 949         if (OC_STACK_OK != ret) {
 950                 ERR("OCStartPresence() Fail(%d)", ret);
 951                 return IOTCON_ERROR_IOTIVITY;
 952         }
 953
 954         return IOTCON_ERROR_NONE;
 955 }
 956
 957
 958 int icd_ioty_stop_presence()
 959 {
 960         OCStackResult ret;
 961
 962         icd_ioty_csdk_lock();
 963         ret = OCStopPresence();
 964         icd_ioty_csdk_unlock();
 965         if (OC_STACK_OK != ret) {
 966                 ERR("OCStopPresence() Fail(%d)", ret);
 967                 return IOTCON_ERROR_IOTIVITY;
 968         }
 969
 970         return IOTCON_ERROR_NONE;
 971 }