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