client/vasum-client.h

   1 /*
   2  *  Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Mateusz Malicki <m.malicki2@samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18
  19
  20 /**
  21  * @file
  22  * @author  Mateusz Malicki (m.malicki2@samsung.com)
  23  * @brief   This file contains the public API for Vasum Client
  24  *
  25  * @par Example usage:
  26  * @code
  27 #include <stdio.h>
  28 #include "client/vasum-client.h"
  29
  30 int main(int argc, char** argv)
  31 {
  32     VsmStatus status;
  33     VsmClient client;
  34     VsmArrayString values = NULL;
  35     int ret = 0;
  36
  37     status = vsm_start_glib_loop(); // start glib loop (if not started any yet)
  38     if (VSMCLIENT_SUCCESS != status) {
  39         // error!
  40         return 1;
  41     }
  42
  43     client = vsm_client_create(); // create client handle
  44     if (NULL == client) {
  45         // error!
  46         ret = 1;
  47         goto finish;
  48     }
  49
  50     status = vsm_connect(client); // connect to dbus
  51     if (VSMCLIENT_SUCCESS != status) {
  52         // error!
  53         ret = 1;
  54         goto finish;
  55     }
  56
  57     status = vsm_get_zone_ids(client, &values);
  58     if (VSMCLIENT_SUCCESS != status) {
  59         // error!
  60         ret = 1;
  61         goto finish;
  62     }
  63
  64     // print array
  65     for (VsmArrayString iValues = values; *iValues; iValues++) {
  66         printf("%s\n", *iValues);
  67     }
  68
  69 finish:
  70     vsm_array_string_free(values); // free memory
  71     vsm_client_free(client); // destroy client handle
  72     vsm_stop_glib_loop(); // stop the glib loop (use only with vsm_start_glib_loop)
  73     return ret;
  74 }
  75  @endcode
  76  */
  77
  78 #ifndef VASUM_CLIENT_H
  79 #define VASUM_CLIENT_H
  80
  81 #include <stdint.h>
  82 #include <sys/stat.h>
  83 #include <netinet/ip.h>
  84 #include <linux/if_link.h>
  85
  86 #ifdef __cplusplus
  87 extern "C"
  88 {
  89 #endif
  90
  91 /**
  92  * vasum-server's client pointer.
  93  */
  94 typedef void* VsmClient;
  95
  96 /**
  97  * NULL-terminated string type.
  98  *
  99  * @sa vsm_array_string_free
 100  */
 101 typedef char* VsmString;
 102
 103 /**
 104  * NULL-terminated array of strings type.
 105  *
 106  * @sa vsm_string_free
 107  */
 108 typedef VsmString* VsmArrayString;
 109
 110 /**
 111  * Completion status of communication function.
 112  */
 113 typedef enum {
 114     VSMCLIENT_CUSTOM_ERROR,     /**< User specified error */
 115     VSMCLIENT_IO_ERROR,         /**< Input/Output error */
 116     VSMCLIENT_OPERATION_FAILED, /**< Operation failed */
 117     VSMCLIENT_INVALID_ARGUMENT, /**< Invalid argument */
 118     VSMCLIENT_OTHER_ERROR,      /**< Other error */
 119     VSMCLIENT_SUCCESS           /**< Success */
 120 } VsmStatus;
 121
 122 /**
 123  * Subscription id
 124  */
 125 typedef unsigned int VsmSubscriptionId;
 126
 127 /**
 128  * States of zone
 129  */
 130 typedef enum {
 131     STOPPED,
 132     STARTING,
 133     RUNNING,
 134     STOPPING,
 135     ABORTING,
 136     FREEZING,
 137     FROZEN,
 138     THAWED,
 139     LOCKED,
 140     MAX_STATE,
 141     ACTIVATING = 128
 142 } VsmZoneState;
 143
 144 /**
 145  * Zone information structure
 146  */
 147 typedef struct {
 148     char* id;
 149     int terminal;
 150     VsmZoneState state;
 151     char *rootfs_path;
 152 } VsmZoneStructure;
 153
 154 /**
 155  * Zone information
 156  */
 157 typedef VsmZoneStructure* VsmZone;
 158
 159 /**
 160  * Netowrk device type
 161  */
 162 typedef enum {
 163     VSMNETDEV_VETH,
 164     VSMNETDEV_PHYS,
 165     VSMNETDEV_MACVLAN
 166 } VsmNetdevType;
 167
 168 /**
 169  * Network device information structure
 170  */
 171 typedef struct {
 172     char* name;
 173     VsmNetdevType type;
 174 } VsmNetdevStructure;
 175
 176 /**
 177  * Network device information
 178  */
 179 typedef VsmNetdevStructure* VsmNetdev;
 180
 181 /**
 182  * File type
 183  */
 184 typedef enum {
 185     VSMFILE_DIRECTORY,
 186     VSMFILE_FIFO,
 187     VSMFILE_REGULAR
 188 } VsmFileType;
 189
 190 #ifndef __VASUM_WRAPPER_SOURCE__
 191 /**
 192  * Start glib loop.
 193  *
 194  * Do not call this function if an application creates a glib loop itself.
 195  * Otherwise, call it before any other function from this library.
 196  *
 197  * @return status of this function call
 198  */
 199 VsmStatus vsm_start_glib_loop();
 200
 201 /**
 202  * Stop glib loop.
 203  *
 204  * Call only if vsm_start_glib_loop() was called.
 205  *
 206  * @return status of this function call
 207  */
 208 VsmStatus vsm_stop_glib_loop();
 209
 210 /**
 211  * Create a new vasum-server's client.
 212  *
 213  * @return Created client pointer or NULL on failure.
 214  */
 215 VsmClient vsm_client_create();
 216
 217 /**
 218  * Release client resources.
 219  *
 220  * @param[in] client vasum-server's client
 221  */
 222 void vsm_client_free(VsmClient client);
 223
 224 /**
 225  * Get status code of last vasum-server communication.
 226  *
 227  * @param[in] client vasum-server's client
 228  * @return status of this function call
 229  */
 230 VsmStatus vsm_get_status(VsmClient client);
 231
 232 /**
 233  * Get status message of the last vasum-server communication.
 234  *
 235  * @param[in] client vasum-server's client
 236  * @return last status message from vasum-server communication
 237  */
 238 const char* vsm_get_status_message(VsmClient client);
 239
 240 /**
 241  * Connect client to the vasum-server.
 242  *
 243  * @param[in] client vasum-server's client
 244  * @return status of this function call
 245  */
 246 VsmStatus vsm_connect(VsmClient client);
 247
 248 /**
 249  * Connect client to the vasum-server via custom address.
 250  *
 251  * @param[in] client vasum-server's client
 252  * @param[in] address dbus address
 253  * @return status of this function call
 254  */
 255 VsmStatus vsm_connect_custom(VsmClient client, const char* address);
 256
 257 /**
 258  * Release VsmArrayString.
 259  *
 260  * @param[in] astring VsmArrayString
 261  */
 262 void vsm_array_string_free(VsmArrayString astring);
 263
 264 /**
 265  * Release VsmString.
 266  *
 267  * @param string VsmString
 268  */
 269 void vsm_string_free(VsmString string);
 270
 271 /**
 272  * Release VsmZone
 273  *
 274  * @param zone VsmZone
 275  */
 276 void vsm_zone_free(VsmZone zone);
 277
 278 /**
 279  * Release VsmNetdev
 280  *
 281  * @param netdev VsmNetdev
 282  */
 283 void vsm_netdev_free(VsmNetdev netdev);
 284
 285 /**
 286  * @name Host API
 287  *
 288  * Functions using org.tizen.vasum.host.manager D-Bus interface.
 289  *
 290  * @{
 291  */
 292
 293 /**
 294  * Zone's D-Bus state change callback function signature.
 295  *
 296  * @param[in] zoneId affected zone id
 297  * @param[in] address new D-Bus address
 298  * @param data custom user's data pointer passed to vsm_add_state_callback() function
 299  */
 300 typedef void (*VsmZoneDbusStateCallback)(const char* zoneId,
 301                                              const char* address,
 302                                              void* data);
 303
 304 /**
 305  * Get dbus address of each zone.
 306  *
 307  * @param[in] client vasum-server's client
 308  * @param[out] keys array of zones name
 309  * @param[out] values array of zones dbus address
 310  * @return status of this function call
 311  * @post keys[i] corresponds to values[i]
 312  * @remark Use vsm_array_string_free() to free memory occupied by @p keys and @p values.
 313  */
 314 VsmStatus vsm_get_zone_dbuses(VsmClient client, VsmArrayString* keys, VsmArrayString* values);
 315
 316 /**
 317  * Get zones name.
 318  *
 319  * @param[in] client vasum-server's client
 320  * @param[out] array array of zones name
 321  * @return status of this function call
 322  * @remark Use vsm_array_string_free() to free memory occupied by @p array.
 323  */
 324 VsmStatus vsm_get_zone_ids(VsmClient client, VsmArrayString* array);
 325
 326 /**
 327  * Get active (foreground) zone name.
 328  *
 329  * @param[in] client vasum-server's client
 330  * @param[out] id active zone name
 331  * @return status of this function call
 332  * @remark Use @p vsm_string_free() to free memory occupied by @p id.
 333  */
 334 VsmStatus vsm_get_active_zone_id(VsmClient client, VsmString* id);
 335
 336 /**
 337  * Get zone rootfs path.
 338  *
 339  * @param[in] client vasum-server's client
 340  * @param[in] id zone name
 341  * @param[out] rootpath zone rootfs path
 342  * @return status of this function call
 343  * @remark Use @p vsm_string_free() to free memory occupied by @p rootpath.
 344  */
 345 VsmStatus vsm_get_zone_rootpath(VsmClient client, const char* id, VsmString* rootpath);
 346
 347 /**
 348  * Get zone name of process with given pid.
 349  *
 350  * @param[in] client vasum-server's client
 351  * @param[in] pid process id
 352  * @param[out] id active zone name
 353  * @return status of this function call
 354  * @remark Use @p vsm_string_free() to free memory occupied by @p id.
 355  */
 356 VsmStatus vsm_lookup_zone_by_pid(VsmClient client, int pid, VsmString* id);
 357
 358 /**
 359  * Get zone informations of zone with given id.
 360  *
 361  * @param[in] client vasum-server's client
 362  * @param[in] id zone name
 363  * @param[out] zone zone informations
 364  * @return status of this function call
 365  * @remark Use @p vsm_zone_free() to free memory occupied by @p zone
 366  */
 367 VsmStatus vsm_lookup_zone_by_id(VsmClient client, const char* id, VsmZone* zone);
 368
 369 /**
 370  * Get zone name with given terminal.
 371  *
 372  * @param[in] client vasum-server's client
 373  * @param[in] terminal terminal id
 374  * @param[out] id zone name with given terminal
 375  * @return status of this function call
 376  * @remark Use @p vsm_string_free() to free memory occupied by @p id.
 377  */
 378 VsmStatus vsm_lookup_zone_by_terminal_id(VsmClient client, int terminal, VsmString* id);
 379
 380 /**
 381  * Set active (foreground) zone.
 382  *
 383  * @param[in] client vasum-server's client
 384  * @param[in] id zone name
 385  * @return status of this function call
 386  */
 387 VsmStatus vsm_set_active_zone(VsmClient client, const char* id);
 388
 389 /**
 390  * Create and add zone
 391  *
 392  * @param[in] client vasum-server's client
 393  * @param[in] id zone id
 394  * @param[in] tname template name, NULL is equivalent to "default"
 395  * @return status of this function call
 396  */
 397 VsmStatus vsm_create_zone(VsmClient client, const char* id, const char* tname);
 398
 399 /**
 400  * Remove zone
 401  *
 402  * @param[in] client vasum-server's client
 403  * @param[in] id zone id
 404  * @param[in] force if 0 data will be kept, otherwise data will be lost
 405  * @return status of this function call
 406  */
 407 VsmStatus vsm_destroy_zone(VsmClient client, const char* id, int force);
 408
 409 /**
 410  * Shutdown zone
 411  *
 412  * @param[in] client vasum-server's client
 413  * @param[in] id zone name
 414  * @return status of this function call
 415  */
 416 VsmStatus vsm_shutdown_zone(VsmClient client, const char* id);
 417
 418 /**
 419  * Start zone
 420  *
 421  * @param[in] client vasum-server's client
 422  * @param[in] id zone name
 423  * @return status of this function call
 424  */
 425 VsmStatus vsm_start_zone(VsmClient client, const char* id);
 426
 427 /**
 428  * Lock zone
 429  *
 430  * @param[in] client vasum-server's client
 431  * @param[in] id zone name
 432  * @return status of this function call
 433  */
 434 VsmStatus vsm_lock_zone(VsmClient client, const char* id);
 435
 436 /**
 437  * Unlock zone
 438  *
 439  * @param[in] client vasum-server's client
 440  * @param[in] id zone name
 441  * @return status of this function call
 442  */
 443 VsmStatus vsm_unlock_zone(VsmClient client, const char* id);
 444
 445 /**
 446  * Register dbus state change callback function.
 447  *
 448  * @note The callback function will be invoked on a different thread.
 449  *
 450  * @param[in] client vasum-server's client
 451  * @param[in] zoneDbusStateCallback callback function
 452  * @param[in] data some extra data that will be passed to callback function
 453  * @param[out] subscriptionId subscription identifier that can be used to unsubscribe signal,
 454  *                      pointer can be NULL.
 455  * @return status of this function call
 456  */
 457 VsmStatus vsm_add_state_callback(VsmClient client,
 458                                  VsmZoneDbusStateCallback zoneDbusStateCallback,
 459                                  void* data,
 460                                  VsmSubscriptionId* subscriptionId);
 461
 462 /**
 463  * Unregister dbus state change callback function.
 464  *
 465  * @param[in] client vasum-server's client
 466  * @param[in] subscriptionId subscription identifier returned by vsm_add_state_callback
 467  * @return status of this function call
 468  */
 469 VsmStatus vsm_del_state_callback(VsmClient client, VsmSubscriptionId subscriptionId);
 470
 471 /**
 472  * Grant access to device
 473  *
 474  * @param[in] client vasum-server's client
 475  * @param[in] zone zone name
 476  * @param[in] device device path
 477  * @param[in] flags access flags
 478  * @return status of this function call
 479  */
 480 VsmStatus vsm_grant_device(VsmClient client,
 481                            const char* zone,
 482                            const char* device,
 483                            uint32_t flags);
 484
 485 /**
 486  * Revoke access to device
 487  *
 488  * @param[in] client vasum-server's client
 489  * @param[in] zone zone name
 490  * @param[in] device device path
 491  * @return status of this function call
 492  */
 493 VsmStatus vsm_revoke_device(VsmClient client, const char* zone, const char* device);
 494
 495 /**
 496  * Get array of netdev from given zone
 497  *
 498  * @param[in] client vasum-server's client
 499  * @param[in] zone zone name
 500  * @param[out] netdevIds array of netdev id
 501  * @return status of this function call
 502  * @remark Use vsm_array_string_free() to free memory occupied by @p netdevIds.
 503  */
 504 VsmStatus vsm_zone_get_netdevs(VsmClient client, const char* zone, VsmArrayString* netdevIds);
 505
 506 /**
 507  * Get ipv4 address for given netdevId
 508  *
 509  * @param[in] client vasum-server's client
 510  * @param[in] zone zone name
 511  * @param[in] netdevId netdev id
 512  * @param[out] addr ipv4 address
 513  * @return status of this function call
 514  */
 515 VsmStatus vsm_netdev_get_ipv4_addr(VsmClient client,
 516                                    const char* zone,
 517                                    const char* netdevId,
 518                                    struct in_addr *addr);
 519
 520 /**
 521  * Get ipv6 address for given netdevId
 522  *
 523  * @param[in] client vasum-server's client
 524  * @param[in] zone zone name
 525  * @param[in] netdevId netdev id
 526  * @param[out] addr ipv6 address
 527  * @return status of this function call
 528  */
 529 VsmStatus vsm_netdev_get_ipv6_addr(VsmClient client,
 530                                    const char* zone,
 531                                    const char* netdevId,
 532                                    struct in6_addr *addr);
 533
 534 /**
 535  * Set ipv4 address for given netdevId
 536  *
 537  * @param[in] client vasum-server's client
 538  * @param[in] zone zone name
 539  * @param[in] netdevId netdev id
 540  * @param[in] addr ipv4 address
 541  * @param[in] prefix bit-length of the network prefix
 542  * @return status of this function call
 543  */
 544 VsmStatus vsm_netdev_set_ipv4_addr(VsmClient client,
 545                                    const char* zone,
 546                                    const char* netdevId,
 547                                    struct in_addr *addr,
 548                                    int prefix);
 549
 550 /**
 551  * Set ipv6 address for given netdevId
 552  *
 553  * @param[in] client vasum-server's client
 554  * @param[in] zone zone name
 555  * @param[in] netdevId netdev id
 556  * @param[in] addr ipv6 address
 557  * @param[in] prefix bit-length of the network prefix
 558  * @return status of this function call
 559  */
 560 VsmStatus vsm_netdev_set_ipv6_addr(VsmClient client,
 561                                    const char* zone,
 562                                    const char* netdevId,
 563                                    struct in6_addr *addr,
 564                                    int prefix);
 565
 566 /**
 567  * Remove ipv4 address from netdev
 568  *
 569  * @param[in] client vasum-server's client
 570  * @param[in] zone zone name
 571  * @param[in] netdevId network device id
 572  * @param[in] addr ipv4 address
 573  * @param[in] prefix bit-length of the network prefix
 574  * @return status of this function call
 575  */
 576 VsmStatus vsm_netdev_del_ipv4_addr(VsmClient client,
 577                                    const char* zone,
 578                                    const char* netdevId,
 579                                    struct in_addr* addr,
 580                                    int prefix);
 581
 582 /**
 583  * Remove ipv6 address from netdev
 584  *
 585  * @param[in] client vasum-server's client
 586  * @param[in] zone zone name
 587  * @param[in] netdevId network device id
 588  * @param[in] addr ipv6 address
 589  * @param[in] prefix bit-length of the network prefix
 590  * @return status of this function call
 591  */
 592 VsmStatus vsm_netdev_del_ipv6_addr(VsmClient client,
 593                                    const char* zone,
 594                                    const char* netdevId,
 595                                    struct in6_addr* addr,
 596                                    int prefix);
 597
 598 /**
 599  * Turn up a network device in the zone
 600  *
 601  * @param[in] client vasum-server's client
 602  * @param[in] zone zone name
 603  * @param[in] netdevId netdev id
 604  * @return status of this function call
 605  */
 606 VsmStatus vsm_netdev_up(VsmClient client,
 607                         const char* zone,
 608                         const char* netdevId);
 609
 610 /**
 611  * Turn down a network device in the zone
 612  *
 613  * @param[in] client vasum-server's client
 614  * @param[in] zone zone name
 615  * @param[in] netdevId netdev id
 616  * @return status of this function call
 617  */
 618 VsmStatus vsm_netdev_down(VsmClient client,
 619                           const char* zone,
 620                           const char* netdevId);
 621
 622
 623 /**
 624  * Create veth netdev in zone
 625  *
 626  * @param[in] client vasum-server's client
 627  * @param[in] zone zone name
 628  * @param[in] zoneDev in host network device id
 629  * @param[in] hostDev in zone network device id
 630  * @return status of this function call
 631  */
 632 VsmStatus vsm_create_netdev_veth(VsmClient client,
 633                                  const char* zone,
 634                                  const char* zoneDev,
 635                                  const char* hostDev);
 636 /**
 637  * Create macvlab in zone
 638  *
 639  * @param[in] client vasum-server's client
 640  * @param[in] zone zone name
 641  * @param[in] zoneDev in host network device id
 642  * @param[in] hostDev in zone network device id
 643  * @return status of this function call
 644  */
 645 VsmStatus vsm_create_netdev_macvlan(VsmClient client,
 646                                     const char* zone,
 647                                     const char* zoneDev,
 648                                     const char* hostDev,
 649                                     enum macvlan_mode mode);
 650 /**
 651  * Create/move phys netdev in/to zone
 652  *
 653  * @param[in] client vasum-server's client
 654  * @param[in] zone zone name
 655  * @param[in] devId network device id
 656  * @return status of this function call
 657  */
 658 VsmStatus vsm_create_netdev_phys(VsmClient client, const char* zone, const char* devId);
 659
 660 /**
 661  * Get netdev informations
 662  *
 663  * @param[in] client vasum-server's client
 664  * @param[in] zone zone name
 665  * @param[in] netdevId network device id
 666  * @param[out] netdev netdev informations
 667  * @return status of this function call
 668  * @remark Use vsm_netdev_free() to free memory occupied by @p netdev.
 669  */
 670 VsmStatus vsm_lookup_netdev_by_name(VsmClient client,
 671                                     const char* zone,
 672                                     const char* netdevId,
 673                                     VsmNetdev* netdev);
 674
 675 /**
 676  * Remove netdev from zone
 677  *
 678  * @param[in] client vasum-server's client
 679  * @param[in] zone zone name
 680  * @param[in] devId network device id
 681  * @return status of this function call
 682  */
 683 VsmStatus vsm_destroy_netdev(VsmClient client, const char* zone, const char* devId);
 684
 685 /**
 686  * Create file, directory or pipe in zone
 687  *
 688  * Declare file, directory or pipe that will be created while zone startup
 689  *
 690  * @param[in] client vasum-server's client
 691  * @param[in] type file type
 692  * @param[in] zone zone id
 693  * @param[in] path path to file
 694  * @param[in] flags if O_CREAT bit is set then file will be created in zone,
 695  *                  otherwise file will by copied from host;
 696  *                  it is meaningful only when O_CREAT is set
 697  * @param[in] mode mode of file
 698  * @return status of this function call
 699  */
 700 VsmStatus vsm_declare_file(VsmClient client,
 701                            const char* zone,
 702                            VsmFileType type,
 703                            const char* path,
 704                            int32_t flags,
 705                            mode_t mode);
 706
 707 /**
 708  * Create mount point in zone
 709  *
 710  * Declare mount that will be created while zone startup
 711  * Parameters are passed to mount system function
 712  *
 713  * @param[in] client vasum-server's client
 714  * @param[in] source device path (path in host)
 715  * @param[in] zone zone id
 716  * @param[in] target mount point (path in zone)
 717  * @param[in] type filesystem type
 718  * @param[in] flags mount flags as in mount function
 719  * @param[in] data additional data as in mount function
 720  * @return status of this function call
 721  */
 722 VsmStatus vsm_declare_mount(VsmClient client,
 723                             const char* source,
 724                             const char* zone,
 725                             const char* target,
 726                             const char* type,
 727                             uint64_t flags,
 728                             const char* data);
 729
 730 /**
 731  * Create link in zone
 732  *
 733  * Declare link that will be created while zone startup
 734  * Parameters are passed to link system function
 735  *
 736  * @param[in] client vasum-server's client
 737  * @param[in] source path to link source (in host)
 738  * @param[in] zone zone id
 739  * @param[in] target path to link name (in zone)
 740  * @return status of this function call
 741  */
 742 VsmStatus vsm_declare_link(VsmClient client,
 743                            const char *source,
 744                            const char* zone,
 745                            const char *target);
 746
 747 /**
 748  * Get all declarations
 749  *
 750  * Gets all declarations of resourcies
 751  * (@see ::vsm_declare_link, @see ::vsm_declare_mount, @see ::vsm_declare_linki)
 752  *
 753  * @param[in] client vasum-server's client
 754  * @param[in] zone zone id
 755  * @param[out] declarations array of declarations id
 756  * @return status of this function call
 757  */
 758 VsmStatus vsm_list_declarations(VsmClient client,
 759                                 const char* zone,
 760                                 VsmArrayString* declarations);
 761
 762 /**
 763  * Remove declaration
 764  *
 765  * Removes given declaration by its id (@see ::vsm_list_declarations)
 766  *
 767  * @param[in] client vasum-server's client
 768  * @param[in] zone zone id
 769  * @param[in] declaration declaration id
 770  * @return status of this function call
 771  */
 772 VsmStatus vsm_remove_declaration(VsmClient client,
 773                                  const char* zone,
 774                                  VsmString declaration);
 775
 776
 777 /** @} Host API */
 778
 779
 780 /**
 781  * @name Zone API
 782  *
 783  * Functions using org.tizen.vasum.zone.manager D-Bus interface.
 784  *
 785  * @{
 786  */
 787
 788 /**
 789  * Notification callback function signature.
 790  *
 791  * @param[in] zone source zone
 792  * @param[in] application sending application name
 793  * @param[in] message notification message
 794  * @param data custom user's data pointer passed to vsm_add_notification_callback()
 795  */
 796 typedef void (*VsmNotificationCallback)(const char* zone,
 797                                         const char* application,
 798                                         const char* message,
 799                                         void* data);
 800 /**
 801  * Send message to active zone.
 802  *
 803  * @param[in] client vasum-server's client
 804  * @param[in] application application name
 805  * @param[in] message message
 806  * @return status of this function call
 807  */
 808 VsmStatus vsm_notify_active_zone(VsmClient client, const char* application, const char* message);
 809
 810 /**
 811  * Move file between zones.
 812  *
 813  * @param[in] client vasum-server's client
 814  * @param[in] destZone destination zone id
 815  * @param[in] path path to moved file
 816  * @return status of this function call
 817  */
 818 VsmStatus vsm_file_move_request(VsmClient client, const char* destZone, const char* path);
 819
 820 /**
 821  * Register notification callback function.
 822  *
 823  * @note The callback function will be invoked on a different thread.
 824  *
 825  * @param[in] client vasum-server's client
 826  * @param[in] notificationCallback callback function
 827  * @param[in] data some extra data that will be passed to callback function
 828  * @param[out] subscriptionId subscription identifier that can be used to unsubscribe signal,
 829  *                      pointer can be NULL.
 830  * @return status of this function call
 831  */
 832 VsmStatus vsm_add_notification_callback(VsmClient client,
 833                                         VsmNotificationCallback notificationCallback,
 834                                         void* data,
 835                                         VsmSubscriptionId* subscriptionId);
 836
 837 /**
 838  * Unregister notification callback function.
 839  *
 840  * @param[in] client vasum-server's client
 841  * @param[in] subscriptionId subscription identifier returned by vsm_add_notification_callback
 842  * @return status of this function call
 843  */
 844 VsmStatus vsm_del_notification_callback(VsmClient client, VsmSubscriptionId subscriptionId);
 845
 846 #endif /* __VASUM_WRAPPER_SOURCE__ */
 847
 848 /** @} Zone API */
 849
 850 #ifdef __cplusplus
 851 }
 852 #endif
 853
 854 #endif /* VASUM_CLIENT_H */