client/vasum-client.cpp

   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
  26 #include <config.hpp>
  27 #include "vasum-client.h"
  28 #include "vasum-client-impl.hpp"
  29
  30 #include <cassert>
  31
  32 #ifndef API
  33 #define API __attribute__((visibility("default")))
  34 #endif // API
  35
  36 using namespace std;
  37
  38 namespace {
  39
  40 Client& getClient(VsmClient client)
  41 {
  42     assert(client);
  43     return *reinterpret_cast<Client*>(client);
  44 }
  45
  46 } // namespace
  47
  48 /* external */
  49 API VsmStatus vsm_start_glib_loop()
  50 {
  51     return Client::vsm_start_glib_loop();
  52 }
  53
  54 API VsmStatus vsm_stop_glib_loop()
  55 {
  56     return Client::vsm_stop_glib_loop();
  57 }
  58
  59 API VsmClient vsm_client_create()
  60 {
  61     Client* clientPtr = new(nothrow) Client();
  62     return reinterpret_cast<VsmClient>(clientPtr);
  63 }
  64
  65 API VsmStatus vsm_connect(VsmClient client)
  66 {
  67     return getClient(client).createSystem();
  68 }
  69
  70 API VsmStatus vsm_connect_custom(VsmClient client, const char* address)
  71 {
  72     return getClient(client).create(address);
  73 }
  74
  75 API void vsm_array_string_free(VsmArrayString astring)
  76 {
  77     if (!astring) {
  78         return;
  79     }
  80     for (char** ptr = astring; *ptr; ++ptr) {
  81         vsm_string_free(*ptr);
  82     }
  83     free(astring);
  84 }
  85
  86 API void vsm_string_free(VsmString string)
  87 {
  88     free(string);
  89 }
  90
  91 API void vsm_zone_free(VsmZone zone)
  92 {
  93     free(zone->rootfs_path);
  94     free(zone->id);
  95     free(zone);
  96 }
  97
  98 API void vsm_netdev_free(VsmNetdev netdev)
  99 {
 100     free(netdev->name);
 101     free(netdev);
 102 }
 103
 104 API void vsm_client_free(VsmClient client)
 105 {
 106     if (client != NULL) {
 107         delete &getClient(client);
 108     }
 109 }
 110
 111 API const char* vsm_get_status_message(VsmClient client)
 112 {
 113     return getClient(client).vsm_get_status_message();
 114 }
 115
 116 API VsmStatus vsm_get_status(VsmClient client)
 117 {
 118     return getClient(client).vsm_get_status();
 119 }
 120
 121 API VsmStatus vsm_get_zone_dbuses(VsmClient client, VsmArrayString* keys, VsmArrayString* values)
 122 {
 123     return getClient(client).vsm_get_zone_dbuses(keys, values);
 124 }
 125
 126 API VsmStatus vsm_get_zone_ids(VsmClient client, VsmArrayString* array)
 127 {
 128     return getClient(client).vsm_get_zone_ids(array);
 129 }
 130
 131 API VsmStatus vsm_get_active_zone_id(VsmClient client, VsmString* id)
 132 {
 133     return getClient(client).vsm_get_active_zone_id(id);
 134 }
 135
 136 API VsmStatus vsm_lookup_zone_by_pid(VsmClient client, int pid, VsmString* id)
 137 {
 138     return getClient(client).vsm_lookup_zone_by_pid(pid, id);
 139 }
 140
 141 API VsmStatus vsm_lookup_zone_by_id(VsmClient client, const char* id, VsmZone* zone)
 142 {
 143     return getClient(client).vsm_lookup_zone_by_id(id, zone);
 144 }
 145
 146 API VsmStatus vsm_lookup_zone_by_terminal_id(VsmClient client, int terminal, VsmString* id)
 147 {
 148     return getClient(client).vsm_lookup_zone_by_terminal_id(terminal, id);
 149 }
 150
 151 API VsmStatus vsm_set_active_zone(VsmClient client, const char* id)
 152 {
 153     return getClient(client).vsm_set_active_zone(id);
 154 }
 155
 156 API VsmStatus vsm_create_zone(VsmClient client, const char* id, const char* tname)
 157 {
 158     return getClient(client).vsm_create_zone(id, tname);
 159 }
 160
 161 API VsmStatus vsm_destroy_zone(VsmClient client, const char* id, int /*force*/)
 162 {
 163     return getClient(client).vsm_destroy_zone(id);
 164 }
 165
 166 API VsmStatus vsm_shutdown_zone(VsmClient client, const char* id)
 167 {
 168     return getClient(client).vsm_shutdown_zone(id);
 169 }
 170
 171 API VsmStatus vsm_start_zone(VsmClient client, const char* id)
 172 {
 173     return getClient(client).vsm_start_zone(id);
 174 }
 175
 176 API VsmStatus vsm_lock_zone(VsmClient client, const char* id)
 177 {
 178     return getClient(client).vsm_lock_zone(id);
 179 }
 180
 181 API VsmStatus vsm_unlock_zone(VsmClient client, const char* id)
 182 {
 183     return getClient(client).vsm_unlock_zone(id);
 184 }
 185
 186 API VsmStatus vsm_add_state_callback(VsmClient client,
 187                                      VsmZoneDbusStateCallback zoneDbusStateCallback,
 188                                      void* data,
 189                                      VsmSubscriptionId* subscriptionId)
 190 {
 191     return getClient(client).vsm_add_state_callback(zoneDbusStateCallback, data, subscriptionId);
 192 }
 193
 194 API VsmStatus vsm_del_state_callback(VsmClient client, VsmSubscriptionId subscriptionId)
 195 {
 196     return getClient(client).vsm_del_state_callback(subscriptionId);
 197 }
 198
 199 API VsmStatus vsm_grant_device(VsmClient client,
 200                                const char* id,
 201                                const char* device,
 202                                uint32_t flags)
 203 {
 204     return getClient(client).vsm_grant_device(id, device, flags);
 205 }
 206
 207 API VsmStatus vsm_revoke_device(VsmClient client, const char* id, const char* device)
 208 {
 209     return getClient(client).vsm_revoke_device(id, device);
 210 }
 211
 212 API VsmStatus vsm_zone_get_netdevs(VsmClient client,
 213                                      const char* zone,
 214                                      VsmArrayString* netdevIds)
 215 {
 216     return getClient(client).vsm_zone_get_netdevs(zone, netdevIds);
 217 }
 218
 219 API VsmStatus vsm_netdev_get_ipv4_addr(VsmClient client,
 220                                        const char* zone,
 221                                        const char* netdevId,
 222                                        struct in_addr *addr)
 223 {
 224     return getClient(client).vsm_netdev_get_ipv4_addr(zone, netdevId, addr);
 225 }
 226
 227 API VsmStatus vsm_netdev_get_ipv6_addr(VsmClient client,
 228                                        const char* zone,
 229                                        const char* netdevId,
 230                                        struct in6_addr *addr)
 231 {
 232     return getClient(client).vsm_netdev_get_ipv6_addr(zone, netdevId, addr);
 233 }
 234
 235 API VsmStatus vsm_netdev_set_ipv4_addr(VsmClient client,
 236                                        const char* zone,
 237                                        const char* netdevId,
 238                                        struct in_addr *addr,
 239                                        int prefix)
 240 {
 241     return getClient(client).vsm_netdev_set_ipv4_addr(zone, netdevId, addr, prefix);
 242 }
 243
 244 API VsmStatus vsm_netdev_set_ipv6_addr(VsmClient client,
 245                                        const char* zone,
 246                                        const char* netdevId,
 247                                        struct in6_addr *addr,
 248                                        int prefix)
 249 {
 250     return getClient(client).vsm_netdev_set_ipv6_addr(zone, netdevId, addr, prefix);
 251 }
 252
 253 API VsmStatus vsm_create_netdev_veth(VsmClient client,
 254                                      const char* zone,
 255                                      const char* zoneDev,
 256                                      const char* hostDev)
 257 {
 258     return getClient(client).vsm_create_netdev_veth(zone, zoneDev, hostDev);
 259 }
 260
 261 API VsmStatus vsm_create_netdev_macvlan(VsmClient client,
 262                                         const char* zone,
 263                                         const char* zoneDev,
 264                                         const char* hostDev,
 265                                         enum macvlan_mode mode)
 266 {
 267     return getClient(client).vsm_create_netdev_macvlan(zone, zoneDev, hostDev, mode);
 268 }
 269
 270 API VsmStatus vsm_create_netdev_phys(VsmClient client, const char* zone, const char* devId)
 271 {
 272     return getClient(client).vsm_create_netdev_phys(zone, devId);
 273 }
 274
 275 API VsmStatus vsm_lookup_netdev_by_name(VsmClient client,
 276                                         const char* zone,
 277                                         const char* netdevId,
 278                                         VsmNetdev* netdev)
 279 {
 280     return getClient(client).vsm_lookup_netdev_by_name(zone, netdevId, netdev);
 281 }
 282
 283 API VsmStatus vsm_destroy_netdev(VsmClient client, const char* zone, const char* devId)
 284 {
 285     return getClient(client).vsm_destroy_netdev(zone, devId);
 286 }
 287
 288 API VsmStatus vsm_declare_file(VsmClient client,
 289                                const char* zone,
 290                                VsmFileType type,
 291                                const char* path,
 292                                int32_t flags,
 293                                mode_t mode)
 294 {
 295     return getClient(client).vsm_declare_file(zone, type, path, flags, mode, NULL);
 296 }
 297
 298
 299 API VsmStatus vsm_declare_mount(VsmClient client,
 300                                 const char* source,
 301                                 const char* zone,
 302                                 const char* target,
 303                                 const char* type,
 304                                 uint64_t flags,
 305                                 const char* data)
 306 {
 307     return getClient(client).vsm_declare_mount(source, zone, target, type, flags, data, NULL);
 308 }
 309
 310 API VsmStatus vsm_declare_link(VsmClient client,
 311                                const char* source,
 312                                const char* zone,
 313                                const char* target)
 314 {
 315     return getClient(client).vsm_declare_link(source, zone, target, NULL);
 316 }
 317
 318 API VsmStatus vsm_list_declarations(VsmClient client,
 319                                     const char* zone,
 320                                     VsmArrayString* declarations)
 321 {
 322     return getClient(client).vsm_list_declarations(zone, declarations);
 323 }
 324
 325 API VsmStatus vsm_remove_declaration(VsmClient client,
 326                                      const char* zone,
 327                                      VsmString declaration)
 328 {
 329     return getClient(client).vsm_remove_declaration(zone, declaration);
 330 }
 331
 332 API VsmStatus vsm_notify_active_zone(VsmClient client,
 333                                           const char* application,
 334                                           const char* message)
 335 {
 336     return getClient(client).vsm_notify_active_zone(application, message);
 337 }
 338
 339 API VsmStatus vsm_file_move_request(VsmClient client, const char* destZone, const char* path)
 340 {
 341     return getClient(client).vsm_file_move_request(destZone, path);
 342 }
 343
 344 API VsmStatus vsm_add_notification_callback(VsmClient client,
 345                                             VsmNotificationCallback notificationCallback,
 346                                             void* data,
 347                                             VsmSubscriptionId* subscriptionId)
 348 {
 349     return getClient(client).vsm_add_notification_callback(notificationCallback, data, subscriptionId);
 350 }
 351
 352 API VsmStatus vsm_del_notification_callback(VsmClient client,
 353                                             VsmSubscriptionId subscriptionId)
 354 {
 355     return getClient(client).vsm_del_notification_callback(subscriptionId);
 356 }
 357