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_ip_addr(VsmClient client,
 283                                  const char* zone,
 284                                  const char* netdevId,
 285                                  VsmAddrList *addrs)
 286 {
 287     std::vector<InetAddr> addrlist;
 288     VsmStatus status = getClient(client).vsm_netdev_get_ip_addr(zone, netdevId, addrlist);
 289     int n = addrlist.size();
 290     InetAddr *a = (InetAddr *)malloc((n+1)*sizeof(InetAddr));
 291     std::copy(addrlist.begin(), addrlist.end(), a);
 292     a[n].type=-1;
 293     *addrs = a;
 294     return status;
 295 }
 296
 297 API VsmStatus vsm_netdev_get_ipv4_addr(VsmClient client,
 298                                        const char* zone,
 299                                        const char* netdevId,
 300                                        struct in_addr *addr)
 301 {
 302     return getClient(client).vsm_netdev_get_ipv4_addr(zone, netdevId, addr);
 303 }
 304
 305 API VsmStatus vsm_netdev_get_ipv6_addr(VsmClient client,
 306                                        const char* zone,
 307                                        const char* netdevId,
 308                                        struct in6_addr *addr)
 309 {
 310     return getClient(client).vsm_netdev_get_ipv6_addr(zone, netdevId, addr);
 311 }
 312
 313 API VsmStatus vsm_netdev_add_ipv4_addr(VsmClient client,
 314                                        const char* zone,
 315                                        const char* netdevId,
 316                                        struct in_addr *addr,
 317                                        int prefix)
 318 {
 319     return getClient(client).vsm_netdev_add_ipv4_addr(zone, netdevId, addr, prefix);
 320 }
 321
 322 API VsmStatus vsm_netdev_add_ipv6_addr(VsmClient client,
 323                                        const char* zone,
 324                                        const char* netdevId,
 325                                        struct in6_addr *addr,
 326                                        int prefix)
 327 {
 328     return getClient(client).vsm_netdev_add_ipv6_addr(zone, netdevId, addr, prefix);
 329 }
 330
 331 API VsmStatus vsm_netdev_del_ipv4_addr(VsmClient client,
 332                                        const char* zone,
 333                                        const char* netdevId,
 334                                        struct in_addr* addr,
 335                                        int prefix)
 336 {
 337     return getClient(client).vsm_netdev_del_ipv4_addr(zone, netdevId, addr, prefix);
 338 }
 339
 340 API VsmStatus vsm_netdev_del_ipv6_addr(VsmClient client,
 341                                        const char* zone,
 342                                        const char* netdevId,
 343                                        struct in6_addr* addr,
 344                                        int prefix)
 345 {
 346     return getClient(client).vsm_netdev_del_ipv6_addr(zone, netdevId, addr, prefix);
 347 }
 348
 349 API VsmStatus vsm_netdev_up(VsmClient client,
 350                             const char* zone,
 351                             const char* netdevId)
 352 {
 353     return getClient(client).vsm_netdev_up(zone, netdevId);
 354 }
 355
 356 API VsmStatus vsm_netdev_down(VsmClient client,
 357                               const char* zone,
 358                               const char* netdevId)
 359 {
 360     return getClient(client).vsm_netdev_down(zone, netdevId);
 361 }
 362
 363 API VsmStatus vsm_create_netdev_veth(VsmClient client,
 364                                      const char* zone,
 365                                      const char* zoneDev,
 366                                      const char* hostDev)
 367 {
 368     return getClient(client).vsm_create_netdev_veth(zone, zoneDev, hostDev);
 369 }
 370
 371 API VsmStatus vsm_create_netdev_macvlan(VsmClient client,
 372                                         const char* zone,
 373                                         const char* zoneDev,
 374                                         const char* hostDev,
 375                                         enum macvlan_mode mode)
 376 {
 377     return getClient(client).vsm_create_netdev_macvlan(zone, zoneDev, hostDev, mode);
 378 }
 379
 380 API VsmStatus vsm_create_netdev_phys(VsmClient client, const char* zone, const char* devId)
 381 {
 382     return getClient(client).vsm_create_netdev_phys(zone, devId);
 383 }
 384
 385 API VsmStatus vsm_lookup_netdev_by_name(VsmClient client,
 386                                         const char* zone,
 387                                         const char* netdevId,
 388                                         VsmNetdev* netdev)
 389 {
 390     Netdev* n = reinterpret_cast<Netdev*>(netdev);
 391     return getClient(client).vsm_lookup_netdev_by_name(zone, netdevId, n);
 392 }
 393
 394 API VsmStatus vsm_destroy_netdev(VsmClient client, const char* zone, const char* devId)
 395 {
 396     return getClient(client).vsm_destroy_netdev(zone, devId);
 397 }
 398
 399 API VsmStatus vsm_declare_file(VsmClient client,
 400                                const char* zone,
 401                                VsmFileType type,
 402                                const char* path,
 403                                int32_t flags,
 404                                mode_t mode)
 405 {
 406     return getClient(client).vsm_declare_file(zone, type, path, flags, mode, NULL);
 407 }
 408
 409
 410 API VsmStatus vsm_declare_mount(VsmClient client,
 411                                 const char* source,
 412                                 const char* zone,
 413                                 const char* target,
 414                                 const char* type,
 415                                 uint64_t flags,
 416                                 const char* data)
 417 {
 418     return getClient(client).vsm_declare_mount(source, zone, target, type, flags, data, NULL);
 419 }
 420
 421 API VsmStatus vsm_declare_link(VsmClient client,
 422                                const char* source,
 423                                const char* zone,
 424                                const char* target)
 425 {
 426     return getClient(client).vsm_declare_link(source, zone, target, NULL);
 427 }
 428
 429 API VsmStatus vsm_list_declarations(VsmClient client,
 430                                     const char* zone,
 431                                     VsmArrayString* declarations)
 432 {
 433     return getClient(client).vsm_list_declarations(zone, declarations);
 434 }
 435
 436 API VsmStatus vsm_remove_declaration(VsmClient client,
 437                                      const char* zone,
 438                                      VsmString declaration)
 439 {
 440     return getClient(client).vsm_remove_declaration(zone, declaration);
 441 }
 442
 443 API VsmStatus vsm_clean_up_zones_root(VsmClient client)
 444 {
 445     return getClient(client).vsm_clean_up_zones_root();
 446 }
 447
 448 API unsigned int vsm_addrlist_size(VsmAddrList addrs)
 449 {
 450     InetAddr *a = static_cast<InetAddr*>(addrs);
 451     unsigned int i;
 452     for (i = 0; a[i].type >= 0; ++i) ;
 453     return i;
 454 }
 455
 456 API int vsm_addrlist_get_type(VsmAddrList addrs, unsigned int i)
 457 {
 458     return static_cast<InetAddr*>(addrs)[i].type;
 459 }
 460
 461 API const void *vsm_addrlist_get_addr(VsmAddrList addrs, unsigned int i)
 462 {
 463     return &static_cast<InetAddr*>(addrs)[i].addr;
 464 }
 465
 466 API unsigned int vsm_addrlist_get_prefix(VsmAddrList addrs, unsigned int i)
 467 {
 468     return static_cast<InetAddr*>(addrs)[i].prefix;
 469 }
 470
 471 API void vsm_addrlist_free(VsmAddrList addrs) {
 472     free(addrs);
 473 }