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 API VsmStatus vsm_lock_queue(VsmClient client)
  49 {
  50     return getClient(client).vsm_lock_queue();
  51 }
  52
  53 API VsmStatus vsm_unlock_queue(VsmClient client)
  54 {
  55     return getClient(client).vsm_unlock_queue();
  56 }
  57
  58 API VsmStatus vsm_get_poll_fd(VsmClient client, int* fd)
  59 {
  60     return getClient(client).vsm_get_poll_fd(fd);
  61 }
  62
  63 API VsmStatus vsm_enter_eventloop(VsmClient client, int flags, int timeout)
  64 {
  65     return getClient(client).vsm_enter_eventloop(flags, timeout);
  66 }
  67
  68 API VsmStatus vsm_set_dispatcher_type(VsmClient client, VsmDispacherType dispacher)
  69 {
  70     return getClient(client).vsm_set_dispatcher_type(dispacher);
  71 }
  72
  73 API VsmStatus vsm_get_dispatcher_type(VsmClient client, VsmDispacherType* dispacher)
  74 {
  75     return getClient(client).vsm_get_dispatcher_type(dispacher);
  76 }
  77
  78 API VsmClient vsm_client_create()
  79 {
  80     Client* clientPtr = new(nothrow) Client();
  81     return reinterpret_cast<VsmClient>(clientPtr);
  82 }
  83
  84 API VsmStatus vsm_connect(VsmClient client)
  85 {
  86     return getClient(client).connectSystem();
  87 }
  88
  89 API VsmStatus vsm_connect_custom(VsmClient client, const char* address)
  90 {
  91     return getClient(client).connect(address);
  92 }
  93
  94 API VsmStatus vsm_disconnect(VsmClient client)
  95 {
  96     return getClient(client).disconnect();
  97 }
  98
  99 API void vsm_array_string_free(VsmArrayString astring)
 100 {
 101     if (!astring) {
 102         return;
 103     }
 104     for (char** ptr = astring; *ptr; ++ptr) {
 105         vsm_string_free(*ptr);
 106     }
 107     free(astring);
 108 }
 109
 110 API void vsm_string_free(VsmString string)
 111 {
 112     free(string);
 113 }
 114
 115 API VsmString vsm_zone_get_id(VsmZone zone)
 116 {
 117     Zone z = static_cast<Zone>(zone);
 118     return z->id;
 119 }
 120
 121 API int vsm_zone_get_terminal(VsmZone zone)
 122 {
 123     Zone z = static_cast<Zone>(zone);
 124     return z->terminal;
 125 }
 126
 127 API VsmZoneState vsm_zone_get_state(VsmZone zone)
 128 {
 129     Zone z = static_cast<Zone>(zone);
 130     return z->state;
 131 }
 132
 133 API VsmString vsm_zone_get_rootfs(VsmZone zone)
 134 {
 135     Zone z = static_cast<Zone>(zone);
 136     return z->rootfs_path;
 137 }
 138
 139 API void vsm_zone_free(VsmZone zone)
 140 {
 141     Zone z = static_cast<Zone>(zone);
 142     free(z->rootfs_path);
 143     free(z->id);
 144     free(z);
 145 }
 146
 147 API VsmString vsm_netdev_get_name(VsmNetdev netdev)
 148 {
 149     Netdev n = static_cast<Netdev>(netdev);
 150     return n->name;
 151 }
 152
 153 API VsmNetdevType vsm_netdev_get_type(VsmNetdev netdev)
 154 {
 155     Netdev n = static_cast<Netdev>(netdev);
 156     return n->type;
 157 }
 158
 159 API void vsm_netdev_free(VsmNetdev netdev)
 160 {
 161     Netdev n = static_cast<Netdev>(netdev);
 162     free(n->name);
 163     free(n);
 164 }
 165
 166 API void vsm_client_free(VsmClient client)
 167 {
 168     if (client != NULL) {
 169         delete &getClient(client);
 170     }
 171 }
 172
 173 API const char* vsm_get_status_message(VsmClient client)
 174 {
 175     return getClient(client).vsm_get_status_message();
 176 }
 177
 178 API VsmStatus vsm_get_status(VsmClient client)
 179 {
 180     return getClient(client).vsm_get_status();
 181 }
 182
 183 API VsmStatus vsm_get_zone_dbuses(VsmClient client, VsmArrayString* keys, VsmArrayString* values)
 184 {
 185     return getClient(client).vsm_get_zone_dbuses(keys, values);
 186 }
 187
 188 API VsmStatus vsm_get_zone_ids(VsmClient client, VsmArrayString* array)
 189 {
 190     return getClient(client).vsm_get_zone_ids(array);
 191 }
 192
 193 API VsmStatus vsm_get_active_zone_id(VsmClient client, VsmString* id)
 194 {
 195     return getClient(client).vsm_get_active_zone_id(id);
 196 }
 197
 198 API VsmStatus vsm_lookup_zone_by_pid(VsmClient client, int pid, VsmString* id)
 199 {
 200     return getClient(client).vsm_lookup_zone_by_pid(pid, id);
 201 }
 202
 203 API VsmStatus vsm_lookup_zone_by_id(VsmClient client, const char* id, VsmZone* zone)
 204 {
 205     Zone* z = reinterpret_cast<Zone*>(zone);
 206     return getClient(client).vsm_lookup_zone_by_id(id, z);
 207 }
 208
 209 API VsmStatus vsm_lookup_zone_by_terminal_id(VsmClient client, int terminal, VsmString* id)
 210 {
 211     return getClient(client).vsm_lookup_zone_by_terminal_id(terminal, id);
 212 }
 213
 214 API VsmStatus vsm_set_active_zone(VsmClient client, const char* id)
 215 {
 216     return getClient(client).vsm_set_active_zone(id);
 217 }
 218
 219 API VsmStatus vsm_create_zone(VsmClient client, const char* id, const char* tname)
 220 {
 221     return getClient(client).vsm_create_zone(id, tname);
 222 }
 223
 224 API VsmStatus vsm_destroy_zone(VsmClient client, const char* id, int /*force*/)
 225 {
 226     return getClient(client).vsm_destroy_zone(id);
 227 }
 228
 229 API VsmStatus vsm_shutdown_zone(VsmClient client, const char* id)
 230 {
 231     return getClient(client).vsm_shutdown_zone(id);
 232 }
 233
 234 API VsmStatus vsm_start_zone(VsmClient client, const char* id)
 235 {
 236     return getClient(client).vsm_start_zone(id);
 237 }
 238
 239 API VsmStatus vsm_lock_zone(VsmClient client, const char* id)
 240 {
 241     return getClient(client).vsm_lock_zone(id);
 242 }
 243
 244 API VsmStatus vsm_unlock_zone(VsmClient client, const char* id)
 245 {
 246     return getClient(client).vsm_unlock_zone(id);
 247 }
 248
 249 API VsmStatus vsm_add_state_callback(VsmClient client,
 250                                      VsmZoneDbusStateCallback zoneDbusStateCallback,
 251                                      void* data,
 252                                      VsmSubscriptionId* subscriptionId)
 253 {
 254     return getClient(client).vsm_add_state_callback(zoneDbusStateCallback, data, subscriptionId);
 255 }
 256
 257 API VsmStatus vsm_del_state_callback(VsmClient client, VsmSubscriptionId subscriptionId)
 258 {
 259     return getClient(client).vsm_del_state_callback(subscriptionId);
 260 }
 261
 262 API VsmStatus vsm_grant_device(VsmClient client,
 263                                const char* id,
 264                                const char* device,
 265                                uint32_t flags)
 266 {
 267     return getClient(client).vsm_grant_device(id, device, flags);
 268 }
 269
 270 API VsmStatus vsm_revoke_device(VsmClient client, const char* id, const char* device)
 271 {
 272     return getClient(client).vsm_revoke_device(id, device);
 273 }
 274
 275 API VsmStatus vsm_zone_get_netdevs(VsmClient client,
 276                                      const char* zone,
 277                                      VsmArrayString* netdevIds)
 278 {
 279     return getClient(client).vsm_zone_get_netdevs(zone, netdevIds);
 280 }
 281
 282 API VsmStatus vsm_netdev_get_ipv4_addr(VsmClient client,
 283                                        const char* zone,
 284                                        const char* netdevId,
 285                                        struct in_addr *addr)
 286 {
 287     return getClient(client).vsm_netdev_get_ipv4_addr(zone, netdevId, addr);
 288 }
 289
 290 API VsmStatus vsm_netdev_get_ipv6_addr(VsmClient client,
 291                                        const char* zone,
 292                                        const char* netdevId,
 293                                        struct in6_addr *addr)
 294 {
 295     return getClient(client).vsm_netdev_get_ipv6_addr(zone, netdevId, addr);
 296 }
 297
 298 API VsmStatus vsm_netdev_set_ipv4_addr(VsmClient client,
 299                                        const char* zone,
 300                                        const char* netdevId,
 301                                        struct in_addr *addr,
 302                                        int prefix)
 303 {
 304     return getClient(client).vsm_netdev_set_ipv4_addr(zone, netdevId, addr, prefix);
 305 }
 306
 307 API VsmStatus vsm_netdev_set_ipv6_addr(VsmClient client,
 308                                        const char* zone,
 309                                        const char* netdevId,
 310                                        struct in6_addr *addr,
 311                                        int prefix)
 312 {
 313     return getClient(client).vsm_netdev_set_ipv6_addr(zone, netdevId, addr, prefix);
 314 }
 315
 316 API VsmStatus vsm_netdev_del_ipv4_addr(VsmClient client,
 317                                        const char* zone,
 318                                        const char* netdevId,
 319                                        struct in_addr* addr,
 320                                        int prefix)
 321 {
 322     return getClient(client).vsm_netdev_del_ipv4_addr(zone, netdevId, addr, prefix);
 323 }
 324
 325 API VsmStatus vsm_netdev_del_ipv6_addr(VsmClient client,
 326                                        const char* zone,
 327                                        const char* netdevId,
 328                                        struct in6_addr* addr,
 329                                        int prefix)
 330 {
 331     return getClient(client).vsm_netdev_del_ipv6_addr(zone, netdevId, addr, prefix);
 332 }
 333
 334 API VsmStatus vsm_netdev_up(VsmClient client,
 335                             const char* zone,
 336                             const char* netdevId)
 337 {
 338     return getClient(client).vsm_netdev_up(zone, netdevId);
 339 }
 340
 341 API VsmStatus vsm_netdev_down(VsmClient client,
 342                               const char* zone,
 343                               const char* netdevId)
 344 {
 345     return getClient(client).vsm_netdev_down(zone, netdevId);
 346 }
 347
 348 API VsmStatus vsm_create_netdev_veth(VsmClient client,
 349                                      const char* zone,
 350                                      const char* zoneDev,
 351                                      const char* hostDev)
 352 {
 353     return getClient(client).vsm_create_netdev_veth(zone, zoneDev, hostDev);
 354 }
 355
 356 API VsmStatus vsm_create_netdev_macvlan(VsmClient client,
 357                                         const char* zone,
 358                                         const char* zoneDev,
 359                                         const char* hostDev,
 360                                         enum macvlan_mode mode)
 361 {
 362     return getClient(client).vsm_create_netdev_macvlan(zone, zoneDev, hostDev, mode);
 363 }
 364
 365 API VsmStatus vsm_create_netdev_phys(VsmClient client, const char* zone, const char* devId)
 366 {
 367     return getClient(client).vsm_create_netdev_phys(zone, devId);
 368 }
 369
 370 API VsmStatus vsm_lookup_netdev_by_name(VsmClient client,
 371                                         const char* zone,
 372                                         const char* netdevId,
 373                                         VsmNetdev* netdev)
 374 {
 375     Netdev* n = reinterpret_cast<Netdev*>(netdev);
 376     return getClient(client).vsm_lookup_netdev_by_name(zone, netdevId, n);
 377 }
 378
 379 API VsmStatus vsm_destroy_netdev(VsmClient client, const char* zone, const char* devId)
 380 {
 381     return getClient(client).vsm_destroy_netdev(zone, devId);
 382 }
 383
 384 API VsmStatus vsm_declare_file(VsmClient client,
 385                                const char* zone,
 386                                VsmFileType type,
 387                                const char* path,
 388                                int32_t flags,
 389                                mode_t mode)
 390 {
 391     return getClient(client).vsm_declare_file(zone, type, path, flags, mode, NULL);
 392 }
 393
 394
 395 API VsmStatus vsm_declare_mount(VsmClient client,
 396                                 const char* source,
 397                                 const char* zone,
 398                                 const char* target,
 399                                 const char* type,
 400                                 uint64_t flags,
 401                                 const char* data)
 402 {
 403     return getClient(client).vsm_declare_mount(source, zone, target, type, flags, data, NULL);
 404 }
 405
 406 API VsmStatus vsm_declare_link(VsmClient client,
 407                                const char* source,
 408                                const char* zone,
 409                                const char* target)
 410 {
 411     return getClient(client).vsm_declare_link(source, zone, target, NULL);
 412 }
 413
 414 API VsmStatus vsm_list_declarations(VsmClient client,
 415                                     const char* zone,
 416                                     VsmArrayString* declarations)
 417 {
 418     return getClient(client).vsm_list_declarations(zone, declarations);
 419 }
 420
 421 API VsmStatus vsm_remove_declaration(VsmClient client,
 422                                      const char* zone,
 423                                      VsmString declaration)
 424 {
 425     return getClient(client).vsm_remove_declaration(zone, declaration);
 426 }
 427
 428 API VsmStatus vsm_clean_up_zones_root(VsmClient client)
 429 {
 430     return getClient(client).vsm_clean_up_zones_root();
 431 }
 432