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_netdev_up(VsmClient client,
 254                             const char* zone,
 255                             const char* netdevId)
 256 {
 257     return getClient(client).vsm_netdev_up(zone, netdevId);
 258 }
 259
 260 API VsmStatus vsm_netdev_down(VsmClient client,
 261                               const char* zone,
 262                               const char* netdevId)
 263 {
 264     return getClient(client).vsm_netdev_down(zone, netdevId);
 265 }
 266
 267 API VsmStatus vsm_create_netdev_veth(VsmClient client,
 268                                      const char* zone,
 269                                      const char* zoneDev,
 270                                      const char* hostDev)
 271 {
 272     return getClient(client).vsm_create_netdev_veth(zone, zoneDev, hostDev);
 273 }
 274
 275 API VsmStatus vsm_create_netdev_macvlan(VsmClient client,
 276                                         const char* zone,
 277                                         const char* zoneDev,
 278                                         const char* hostDev,
 279                                         enum macvlan_mode mode)
 280 {
 281     return getClient(client).vsm_create_netdev_macvlan(zone, zoneDev, hostDev, mode);
 282 }
 283
 284 API VsmStatus vsm_create_netdev_phys(VsmClient client, const char* zone, const char* devId)
 285 {
 286     return getClient(client).vsm_create_netdev_phys(zone, devId);
 287 }
 288
 289 API VsmStatus vsm_lookup_netdev_by_name(VsmClient client,
 290                                         const char* zone,
 291                                         const char* netdevId,
 292                                         VsmNetdev* netdev)
 293 {
 294     return getClient(client).vsm_lookup_netdev_by_name(zone, netdevId, netdev);
 295 }
 296
 297 API VsmStatus vsm_destroy_netdev(VsmClient client, const char* zone, const char* devId)
 298 {
 299     return getClient(client).vsm_destroy_netdev(zone, devId);
 300 }
 301
 302 API VsmStatus vsm_declare_file(VsmClient client,
 303                                const char* zone,
 304                                VsmFileType type,
 305                                const char* path,
 306                                int32_t flags,
 307                                mode_t mode)
 308 {
 309     return getClient(client).vsm_declare_file(zone, type, path, flags, mode, NULL);
 310 }
 311
 312
 313 API VsmStatus vsm_declare_mount(VsmClient client,
 314                                 const char* source,
 315                                 const char* zone,
 316                                 const char* target,
 317                                 const char* type,
 318                                 uint64_t flags,
 319                                 const char* data)
 320 {
 321     return getClient(client).vsm_declare_mount(source, zone, target, type, flags, data, NULL);
 322 }
 323
 324 API VsmStatus vsm_declare_link(VsmClient client,
 325                                const char* source,
 326                                const char* zone,
 327                                const char* target)
 328 {
 329     return getClient(client).vsm_declare_link(source, zone, target, NULL);
 330 }
 331
 332 API VsmStatus vsm_list_declarations(VsmClient client,
 333                                     const char* zone,
 334                                     VsmArrayString* declarations)
 335 {
 336     return getClient(client).vsm_list_declarations(zone, declarations);
 337 }
 338
 339 API VsmStatus vsm_remove_declaration(VsmClient client,
 340                                      const char* zone,
 341                                      VsmString declaration)
 342 {
 343     return getClient(client).vsm_remove_declaration(zone, declaration);
 344 }
 345
 346 API VsmStatus vsm_notify_active_zone(VsmClient client,
 347                                           const char* application,
 348                                           const char* message)
 349 {
 350     return getClient(client).vsm_notify_active_zone(application, message);
 351 }
 352
 353 API VsmStatus vsm_file_move_request(VsmClient client, const char* destZone, const char* path)
 354 {
 355     return getClient(client).vsm_file_move_request(destZone, path);
 356 }
 357
 358 API VsmStatus vsm_add_notification_callback(VsmClient client,
 359                                             VsmNotificationCallback notificationCallback,
 360                                             void* data,
 361                                             VsmSubscriptionId* subscriptionId)
 362 {
 363     return getClient(client).vsm_add_notification_callback(notificationCallback, data, subscriptionId);
 364 }
 365
 366 API VsmStatus vsm_del_notification_callback(VsmClient client,
 367                                             VsmSubscriptionId subscriptionId)
 368 {
 369     return getClient(client).vsm_del_notification_callback(subscriptionId);
 370 }
 371