src/vine.cpp

   1 /*
   2  * Copyright (c) 2021 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
  18 #include "vine.h"
  19
  20 #include "vine-constants.h"
  21 #include "vine-dp.h"
  22 #include "vine-data-path.h"
  23 #include "vine-event-loop.h"
  24 #include "vine-log.h"
  25 #include "vine-private.h"
  26 #include "vine-security.h"
  27 #include "vine-service.h"
  28 #include "vine-session.h"
  29 #include "vine-utils.h"
  30
  31 API int vine_initialize()
  32 {
  33         __VINE_FUNC_ENTER__;
  34         CHECK_FEATURE_SUPPORTED;
  35
  36         return _vine_init();
  37 }
  38
  39 API int vine_deinitialize()
  40 {
  41         __VINE_FUNC_ENTER__;
  42         CHECK_FEATURE_SUPPORTED;
  43
  44         return _vine_deinit();
  45 }
  46
  47 API int vine_get_capabilities(vine_capability_type_e type, int *capabilities)
  48 {
  49         __VINE_FUNC_ENTER__;
  50         CHECK_FEATURE_SUPPORTED;
  51
  52         return _vine_get_capabilities(type, capabilities);
  53 }
  54
  55 API int vine_session_get_event_fd(vine_session_h session, int *fd)
  56 {
  57         __VINE_FUNC_ENTER__;
  58         CHECK_FEATURE_SUPPORTED;
  59
  60         return _vine_session_get_event_fd(session, fd);
  61 }
  62
  63 API int vine_session_process_event(vine_session_h session)
  64 {
  65         __VINE_FUNC_ENTER__;
  66         CHECK_FEATURE_SUPPORTED;
  67
  68         return _vine_session_process_event(session);
  69 }
  70
  71 API int vine_session_create(vine_session_h *session)
  72 {
  73         __VINE_FUNC_ENTER__;
  74         CHECK_FEATURE_SUPPORTED;
  75
  76         return _vine_session_create(session);
  77 }
  78
  79 API int vine_session_destroy(vine_session_h session)
  80 {
  81         __VINE_FUNC_ENTER__;
  82         CHECK_FEATURE_SUPPORTED;
  83
  84         return _vine_session_destroy(session);
  85 }
  86
  87 API int vine_session_set_registered_cb(vine_session_h session,
  88                 vine_session_registered_cb callback, void *user_data)
  89 {
  90         __VINE_FUNC_ENTER__;
  91         CHECK_FEATURE_SUPPORTED;
  92
  93         return _vine_session_set_registered_cb(session, callback, user_data);
  94 }
  95
  96 API int vine_session_unset_registered_cb(vine_session_h session)
  97 {
  98         __VINE_FUNC_ENTER__;
  99         CHECK_FEATURE_SUPPORTED;
 100
 101         return _vine_session_unset_registered_cb(session);
 102 }
 103
 104 API int vine_session_set_discovered_cb(vine_session_h session,
 105                 vine_session_discovered_cb callback, void *user_data)
 106 {
 107         __VINE_FUNC_ENTER__;
 108         CHECK_FEATURE_SUPPORTED;
 109
 110         return _vine_session_set_discovered_cb(session, callback, user_data);
 111 }
 112
 113 API int vine_session_unset_discovered_cb(vine_session_h session)
 114 {
 115         __VINE_FUNC_ENTER__;
 116         CHECK_FEATURE_SUPPORTED;
 117
 118         return _vine_session_unset_discovered_cb(session);
 119 }
 120
 121 API int vine_session_set_discovery_method(vine_session_h session, vine_discovery_method_e method)
 122 {
 123         __VINE_FUNC_ENTER__;
 124         CHECK_FEATURE_SUPPORTED;
 125
 126         return _vine_session_set_discovery_method(session, method);
 127 }
 128
 129 API int vine_session_register(vine_session_h session,
 130         vine_service_h service, const char *iface_name)
 131 {
 132         __VINE_FUNC_ENTER__;
 133         CHECK_FEATURE_SUPPORTED;
 134
 135         return _vine_session_register(session, service, iface_name);
 136 }
 137
 138 API int vine_session_unregister(vine_session_h session)
 139 {
 140         __VINE_FUNC_ENTER__;
 141         CHECK_FEATURE_SUPPORTED;
 142
 143         return _vine_session_unregister(session);
 144 }
 145
 146 API int vine_session_start_discovery(vine_session_h session,
 147         const char *service_type, const char *iface_name)
 148 {
 149         __VINE_FUNC_ENTER__;
 150         CHECK_FEATURE_SUPPORTED;
 151
 152         return _vine_session_start_discovery(session, service_type, iface_name);
 153 }
 154
 155 API int vine_session_stop_discovery(vine_session_h session)
 156 {
 157         __VINE_FUNC_ENTER__;
 158         CHECK_FEATURE_SUPPORTED;
 159
 160         return _vine_session_stop_discovery(session);
 161 }
 162
 163 API int vine_session_set_ip_resolved_cb(vine_session_h session,
 164         vine_service_h service, vine_session_ip_resolved_cb callback, void *user_data)
 165 {
 166         __VINE_FUNC_ENTER__;
 167         CHECK_FEATURE_SUPPORTED;
 168
 169         return _vine_session_set_ip_resolved_cb(session, service, callback, user_data);
 170 }
 171
 172 API int vine_session_unset_ip_resolved_cb(vine_session_h session,
 173         vine_service_h service)
 174 {
 175         __VINE_FUNC_ENTER__;
 176         CHECK_FEATURE_SUPPORTED;
 177
 178         return _vine_session_unset_ip_resolved_cb(session, service);
 179 }
 180
 181 API int vine_service_create(vine_service_h *service)
 182 {
 183         __VINE_FUNC_ENTER__;
 184         CHECK_FEATURE_SUPPORTED;
 185
 186         return _vine_service_create(service, true);
 187 }
 188
 189 API int vine_service_destroy(vine_service_h service)
 190 {
 191         __VINE_FUNC_ENTER__;
 192         CHECK_FEATURE_SUPPORTED;
 193
 194         return _vine_service_destroy(service);
 195 }
 196
 197 API int vine_service_clone(vine_service_h origin, vine_service_h *cloned)
 198 {
 199         __VINE_FUNC_ENTER__;
 200         CHECK_FEATURE_SUPPORTED;
 201
 202         return _vine_service_clone(origin, cloned);
 203 }
 204
 205 API int vine_service_set_type(vine_service_h service, const char *service_type)
 206 {
 207         __VINE_FUNC_ENTER__;
 208         CHECK_FEATURE_SUPPORTED;
 209
 210         RET_VAL_IF(service == NULL, VINE_ERROR_INVALID_PARAMETER, "service is NULL");
 211         RET_VAL_IF(_is_discovered_service(service), VINE_ERROR_INVALID_OPERATION,
 212                 "cannot set service type for a discovered service");
 213         return _vine_service_set_type(service, service_type);
 214 }
 215
 216 API int vine_service_get_type(vine_service_h service, char **service_type)
 217 {
 218         __VINE_FUNC_ENTER__;
 219         CHECK_FEATURE_SUPPORTED;
 220
 221         RET_VAL_IF(service == NULL, VINE_ERROR_INVALID_PARAMETER, "service is NULL");
 222         RET_VAL_IF(service_type == NULL, VINE_ERROR_INVALID_PARAMETER,
 223                 "service_type is NULL");
 224
 225         *service_type = (char *)strndup(_vine_service_get_type(service),
 226                                                         VINE_MAX_SERVICE_TYPE_LEN);
 227         RET_VAL_IF(*service_type == NULL, VINE_ERROR_OUT_OF_MEMORY, "Out of memory");
 228         return VINE_ERROR_NONE;
 229 }
 230
 231 API int vine_service_set_name(vine_service_h service, const char *service_name)
 232 {
 233         __VINE_FUNC_ENTER__;
 234         CHECK_FEATURE_SUPPORTED;
 235
 236         RET_VAL_IF(service == NULL, VINE_ERROR_INVALID_PARAMETER, "service is NULL");
 237         RET_VAL_IF(_is_discovered_service(service), VINE_ERROR_INVALID_OPERATION,
 238                 "cannot set service name for a discovered service");
 239         return _vine_service_set_name(service, service_name);
 240 }
 241
 242 API int vine_service_get_name(vine_service_h service, char **service_name)
 243 {
 244         __VINE_FUNC_ENTER__;
 245         CHECK_FEATURE_SUPPORTED;
 246
 247         RET_VAL_IF(service == NULL, VINE_ERROR_INVALID_PARAMETER, "service is NULL");
 248         RET_VAL_IF(service_name == NULL, VINE_ERROR_INVALID_PARAMETER,
 249                 "service_name is NULL");
 250
 251         *service_name = (char *)strndup(_vine_service_get_name(service),
 252                                                         VINE_MAX_SERVICE_TYPE_LEN);
 253         RET_VAL_IF(*service_name == NULL, VINE_ERROR_OUT_OF_MEMORY, "Out of memory");
 254         return VINE_ERROR_NONE;
 255 }
 256
 257 API int vine_service_add_attribute(vine_service_h service,
 258         const char *key, const char *value)
 259 {
 260         __VINE_FUNC_ENTER__;
 261         CHECK_FEATURE_SUPPORTED;
 262
 263         RET_VAL_IF(service == NULL, VINE_ERROR_INVALID_PARAMETER, "service is NULL");
 264         RET_VAL_IF(_is_discovered_service(service), VINE_ERROR_INVALID_OPERATION,
 265                 "cannot add attributes for a discovered service");
 266         return _vine_service_add_attribute(service, key, value);
 267 }
 268
 269 API int vine_service_remove_attribute(vine_service_h service, const char *key)
 270 {
 271         __VINE_FUNC_ENTER__;
 272         CHECK_FEATURE_SUPPORTED;
 273
 274         RET_VAL_IF(service == NULL, VINE_ERROR_INVALID_PARAMETER, "service is NULL");
 275         RET_VAL_IF(_is_discovered_service(service), VINE_ERROR_INVALID_OPERATION,
 276                 "cannot add attributes for a discovered service");
 277         return _vine_service_remove_attribute(service, key);
 278 }
 279
 280 API int vine_service_foreach_attribute(vine_service_h service,
 281         vine_service_attribute_cb callback, void *user_data)
 282 {
 283         __VINE_FUNC_ENTER__;
 284         CHECK_FEATURE_SUPPORTED;
 285
 286         return _vine_service_foreach_attribute(service, callback, user_data);
 287 }
 288
 289 API int vine_service_set_port(vine_service_h service, int port)
 290 {
 291         __VINE_FUNC_ENTER__;
 292         CHECK_FEATURE_SUPPORTED;
 293
 294         RET_VAL_IF(service == NULL, VINE_ERROR_INVALID_PARAMETER, "service is NULL");
 295         RET_VAL_IF(_is_discovered_service(service), VINE_ERROR_INVALID_OPERATION,
 296                 "cannot set port for a discovered service");
 297         return _vine_service_set_port(service, port);
 298 }
 299
 300 API int vine_service_get_port(vine_service_h service, int *port)
 301 {
 302         __VINE_FUNC_ENTER__;
 303         CHECK_FEATURE_SUPPORTED;
 304
 305         RET_VAL_IF(service == NULL, VINE_ERROR_INVALID_PARAMETER, "service is NULL");
 306         RET_VAL_IF(port == NULL, VINE_ERROR_INVALID_PARAMETER, "port is NULL");
 307
 308         *port = _vine_service_get_port(service);
 309         return VINE_ERROR_NONE;
 310 }
 311
 312 API int vine_dp_create(vine_session_h session, vine_dp_type_e type, vine_dp_h *dp)
 313 {
 314         __VINE_FUNC_ENTER__;
 315         CHECK_FEATURE_SUPPORTED;
 316
 317         return _vine_dp_create(session, type, dp);
 318 }
 319
 320 API int vine_dp_destroy(vine_dp_h dp)
 321 {
 322         __VINE_FUNC_ENTER__;
 323         CHECK_FEATURE_SUPPORTED;
 324
 325         return _vine_dp_destroy(dp);
 326 }
 327
 328 API int vine_dp_set_iface_name(vine_dp_h dp, const char *iface_name)
 329 {
 330         __VINE_FUNC_ENTER__;
 331         CHECK_FEATURE_SUPPORTED;
 332
 333         return _vine_dp_set_iface_name(dp, iface_name);
 334 }
 335
 336 API int vine_dp_set_address_family(vine_dp_h dp, vine_address_family_e addr_family)
 337 {
 338         __VINE_FUNC_ENTER__;
 339         CHECK_FEATURE_SUPPORTED;
 340
 341         return _vine_dp_set_addr_family(dp, addr_family);
 342 }
 343
 344 API int vine_dp_set_remote_ip(vine_dp_h dp, vine_address_family_e addr_family, const char *ip)
 345 {
 346         __VINE_FUNC_ENTER__;
 347         CHECK_FEATURE_SUPPORTED;
 348
 349         return _vine_dp_set_remote_ip(dp, addr_family, ip);
 350 }
 351
 352 API int vine_dp_set_port(vine_dp_h dp, int port)
 353 {
 354         __VINE_FUNC_ENTER__;
 355         CHECK_FEATURE_SUPPORTED;
 356
 357         return _vine_dp_set_port(dp, port);
 358 }
 359
 360 API int vine_dp_get_port(vine_dp_h dp, int *port)
 361 {
 362         __VINE_FUNC_ENTER__;
 363         CHECK_FEATURE_SUPPORTED;
 364
 365         return _vine_dp_get_port(dp, port);
 366 }
 367
 368 API int vine_dp_set_topic(vine_dp_h dp, const char *topic)
 369 {
 370         __VINE_FUNC_ENTER__;
 371         CHECK_FEATURE_SUPPORTED;
 372
 373         return _vine_dp_set_topic(dp, topic);
 374 }
 375
 376 API int vine_dp_set_max_connections(vine_dp_h dp, int max_conn)
 377 {
 378         __VINE_FUNC_ENTER__;
 379         CHECK_FEATURE_SUPPORTED;
 380
 381         return _vine_dp_set_max_connections(dp, max_conn);
 382 }
 383
 384 API int vine_dp_set_security(vine_dp_h dp, vine_security_h security)
 385 {
 386         __VINE_FUNC_ENTER__;
 387         CHECK_FEATURE_SUPPORTED;
 388
 389         return _vine_dp_set_security(dp, security);
 390 }
 391
 392 API int vine_dp_set_accepted_cb(vine_dp_h dp, vine_dp_accepted_cb callback, void *user_data)
 393 {
 394         __VINE_FUNC_ENTER__;
 395         CHECK_FEATURE_SUPPORTED;
 396
 397         return _vine_dp_set_accepted_cb(dp, callback, user_data);
 398 }
 399
 400 API int vine_dp_unset_accepted_cb(vine_dp_h dp)
 401 {
 402         __VINE_FUNC_ENTER__;
 403         CHECK_FEATURE_SUPPORTED;
 404
 405         return _vine_dp_unset_accepted_cb(dp);
 406 }
 407
 408 API int vine_dp_set_terminated_cb(vine_dp_h dp, vine_dp_terminated_cb callback, void *user_data)
 409 {
 410         __VINE_FUNC_ENTER__;
 411         CHECK_FEATURE_SUPPORTED;
 412
 413         return _vine_dp_set_terminated_cb(dp, callback, user_data);
 414 }
 415
 416 API int vine_dp_unset_terminated_cb(vine_dp_h dp)
 417 {
 418         __VINE_FUNC_ENTER__;
 419         CHECK_FEATURE_SUPPORTED;
 420
 421         return _vine_dp_unset_terminated_cb(dp);
 422 }
 423
 424 API int vine_dp_open(vine_dp_h dp, vine_dp_opened_cb callback, void *user_data)
 425 {
 426         __VINE_FUNC_ENTER__;
 427         CHECK_FEATURE_SUPPORTED;
 428
 429         return _vine_dp_open(dp, callback, user_data);
 430 }
 431
 432 API int vine_dp_close(vine_dp_h dp)
 433 {
 434         __VINE_FUNC_ENTER__;
 435         CHECK_FEATURE_SUPPORTED;
 436
 437         return _vine_dp_close(dp);
 438 }
 439
 440 API int vine_dp_send(vine_dp_h dp, unsigned char *buf, size_t len)
 441 {
 442         __VINE_FUNC_ENTER__;
 443         CHECK_FEATURE_SUPPORTED;
 444
 445         return _vine_dp_send(dp, buf, len);
 446 }
 447
 448 API int vine_dp_recv(vine_dp_h dp,
 449                 unsigned char *buf, size_t buf_len, size_t *read_len)
 450 {
 451         __VINE_FUNC_ENTER__;
 452         CHECK_FEATURE_SUPPORTED;
 453
 454         return _vine_dp_recv(dp, buf, buf_len, read_len);
 455 }
 456
 457 API int vine_dp_set_received_cb(vine_dp_h dp, vine_dp_received_cb callback, void *user_data)
 458 {
 459         __VINE_FUNC_ENTER__;
 460         CHECK_FEATURE_SUPPORTED;
 461
 462         return _vine_dp_set_received_cb(dp, callback, user_data);
 463 }
 464
 465 API int vine_dp_unset_received_cb(vine_dp_h dp)
 466 {
 467         __VINE_FUNC_ENTER__;
 468         CHECK_FEATURE_SUPPORTED;
 469
 470         return _vine_dp_unset_received_cb(dp);
 471 }
 472
 473 API int vine_security_create(vine_security_h *security)
 474 {
 475         __VINE_FUNC_ENTER__;
 476         CHECK_FEATURE_SUPPORTED;
 477
 478         return _vine_security_create(security);
 479 }
 480
 481 API int vine_security_destroy(vine_security_h security)
 482 {
 483         __VINE_FUNC_ENTER__;
 484         CHECK_FEATURE_SUPPORTED;
 485
 486         return _vine_security_destroy(security);
 487 }
 488
 489 API int vine_security_set_type(vine_security_h security, vine_security_type_e type)
 490 {
 491         __VINE_FUNC_ENTER__;
 492         CHECK_FEATURE_SUPPORTED;
 493
 494         return _vine_security_set_type(security, type);
 495 }
 496
 497 API int vine_security_get_type(vine_security_h security, vine_security_type_e *type)
 498 {
 499         __VINE_FUNC_ENTER__;
 500         CHECK_FEATURE_SUPPORTED;
 501
 502         return _vine_security_get_type(security, type);
 503 }
 504
 505 API int vine_security_set_tls_version(vine_security_h security,
 506                 vine_security_tls_version_e version)
 507 {
 508         __VINE_FUNC_ENTER__;
 509         CHECK_FEATURE_SUPPORTED;
 510
 511         return _vine_security_set_tls_version(security, version);
 512 }
 513
 514 API int vine_security_get_tls_version(vine_security_h security,
 515                 vine_security_tls_version_e *version)
 516 {
 517         __VINE_FUNC_ENTER__;
 518         CHECK_FEATURE_SUPPORTED;
 519
 520         return _vine_security_get_tls_version(security, version);
 521 }
 522
 523 API int vine_security_set_verification_flags(vine_security_h security, int flags)
 524 {
 525         __VINE_FUNC_ENTER__;
 526         CHECK_FEATURE_SUPPORTED;
 527
 528         return _vine_security_set_verification_flags(security, flags);
 529 }
 530
 531 API int vine_security_get_verification_flags(vine_security_h security, int*flags)
 532 {
 533         __VINE_FUNC_ENTER__;
 534         CHECK_FEATURE_SUPPORTED;
 535
 536         return _vine_security_get_verification_flags(security, flags);
 537 }
 538
 539 API int vine_security_set_ca_path(vine_security_h security, const char *ca_path)
 540 {
 541         __VINE_FUNC_ENTER__;
 542         CHECK_FEATURE_SUPPORTED;
 543
 544         return _vine_security_set_ca_path(security, ca_path);
 545 }
 546
 547 API int vine_security_get_ca_path(vine_security_h security, char **ca_path)
 548 {
 549         __VINE_FUNC_ENTER__;
 550         CHECK_FEATURE_SUPPORTED;
 551
 552         return _vine_security_get_ca_path(security, ca_path);
 553 }
 554
 555 API int vine_security_set_cert_path(vine_security_h security, const char *cert_path)
 556 {
 557         __VINE_FUNC_ENTER__;
 558         CHECK_FEATURE_SUPPORTED;
 559
 560         return _vine_security_set_cert_path(security, cert_path);
 561 }
 562
 563 API int vine_security_get_cert_path(vine_security_h security, char **cert_path)
 564 {
 565         __VINE_FUNC_ENTER__;
 566         CHECK_FEATURE_SUPPORTED;
 567
 568         return _vine_security_get_cert_path(security, cert_path);
 569 }
 570
 571 API int vine_security_set_private_key(vine_security_h security, const char *key_path)
 572 {
 573         __VINE_FUNC_ENTER__;
 574         CHECK_FEATURE_SUPPORTED;
 575
 576         return _vine_security_set_private_key(security, key_path);
 577 }
 578
 579 API int vine_security_get_private_key(vine_security_h security, char **key_path)
 580 {
 581         __VINE_FUNC_ENTER__;
 582         CHECK_FEATURE_SUPPORTED;
 583
 584         return _vine_security_get_private_key(security, key_path);
 585 }
 586
 587 API int vine_security_set_psk(vine_security_h security, const char *psk)
 588 {
 589         __VINE_FUNC_ENTER__;
 590         CHECK_FEATURE_SUPPORTED;
 591
 592         return _vine_security_set_psk(security, psk);
 593 }
 594
 595 API int vine_security_get_psk(vine_security_h security, char **psk)
 596 {
 597         __VINE_FUNC_ENTER__;
 598         CHECK_FEATURE_SUPPORTED;
 599
 600         return _vine_security_get_psk(security, psk);
 601 }