Merge pull request anbox#1209 from Logout22/master

fix(anbox#1153): compile dbus helpers in C

Author: morphis

src/CMakeLists.txt

@@ -142,7 +142,9 @@ set(SOURCES
     anbox/dbus/bus.h
     anbox/dbus/codecs.h
     anbox/dbus/interface.h
+    anbox/dbus/sd_bus_helpers.c
     anbox/dbus/sd_bus_helpers.h
+    anbox/dbus/sd_bus_helpers.hpp
     anbox/dbus/skeleton/application_manager.cpp
     anbox/dbus/skeleton/application_manager.h
     anbox/dbus/skeleton/service.cpp

src/anbox/dbus/sd_bus_helpers.c

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2019 Martin Unzner <[email protected]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "sd_bus_helpers.h"
+
+sd_bus_vtable sdbus_vtable_create_start(uint64_t flags) {
+  const sd_bus_vtable start = SD_BUS_VTABLE_START(flags);
+  return start;
+}
+
+sd_bus_vtable sdbus_vtable_create_end() {
+  const sd_bus_vtable end = SD_BUS_VTABLE_END;
+  return end;
+}
+
+sd_bus_vtable sdbus_vtable_create_method_o(const char* member, const char* signature,
+                                           const char* result,
+                                           sd_bus_message_handler_t handler, size_t offset,
+                                           uint64_t flags) {
+  const sd_bus_vtable method_o = SD_BUS_METHOD_WITH_OFFSET(
+      member, signature, result, handler, offset, flags);
+  return method_o;
+}
+
+sd_bus_vtable sdbus_vtable_create_method(const char* member, const char* signature,
+                                         const char* result, sd_bus_message_handler_t handler,
+                                         uint64_t flags) {
+  return sdbus_vtable_create_method_o(member, signature, result, handler, 0, flags);
+}
+
+sd_bus_vtable sdbus_vtable_create_signal(const char* member, const char* signature, uint64_t flags) {
+  const sd_bus_vtable signal = SD_BUS_SIGNAL(member, signature, flags);
+  return signal;
+}
+
+sd_bus_vtable sdbus_vtable_create_property(const char* member, const char* signature,
+                                           sd_bus_property_get_t get,
+                                           uint64_t flags) {
+  const sd_bus_vtable property = SD_BUS_PROPERTY(member, signature, get, 0, flags);
+  return property;
+}
+
+sd_bus_vtable sdbus_vtable_create_property_set(const char* member, const char* signature,
+                                               sd_bus_property_get_t get,
+                                               sd_bus_property_set_t set,
+                                               uint64_t flags) {
+  const sd_bus_vtable property = SD_BUS_WRITABLE_PROPERTY(member, signature, get, set, 0, flags);
+  return property;
+}
+
+sd_bus_vtable sdbus_vtable_create_property_o(const char* member, const char* signature,
+                                             size_t offset, uint64_t flags) {
+  const sd_bus_vtable property_o = SD_BUS_PROPERTY(member, signature, NULL, offset, flags);
+  return property_o;
+}
+
+sd_bus_vtable sdbus_vtable_create_property_o_set(const char* member, const char* signature,
+                                                 sd_bus_property_set_t set, size_t offset,
+                                                 uint64_t flags) {
+  const sd_bus_vtable property_o = SD_BUS_WRITABLE_PROPERTY(
+      member, signature, NULL, set, offset, flags);
+  return property_o;
+}

src/anbox/dbus/sd_bus_helpers.h

@@ -1,121 +1,54 @@
 /*
-* Copyright (C) 2018 OpenBMC
-*
-* Taken from https://github.com/openbmc/sdbusplus/blob/master/sdbusplus/vtable.hpp
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2019 Martin Unzner <[email protected]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
 
 #ifndef ANBOX_DBUS_SD_BUS_HELPERS_H_
 #define ANBOX_DBUS_SD_BUS_HELPERS_H_
 
 #include <systemd/sd-bus-vtable.h>
 
-namespace anbox {
-namespace dbus {
-namespace sdbus {
-namespace vtable {
-constexpr sd_bus_vtable start(uint64_t flags)
-{
-  sd_bus_vtable v{};
-  v.type = _SD_BUS_VTABLE_START;
-  v.flags = flags;
-  v.x.start = decltype(v.x.start){sizeof(sd_bus_vtable)};
+sd_bus_vtable sdbus_vtable_create_start(uint64_t flags);
 
-  return v;
-}
+sd_bus_vtable sdbus_vtable_create_end();
 
-constexpr sd_bus_vtable end() {
-  sd_bus_vtable v{};
-  v.type = _SD_BUS_VTABLE_END;
+sd_bus_vtable sdbus_vtable_create_method_o(const char* member, const char* signature,
+                                           const char* result,
+                                           sd_bus_message_handler_t handler, size_t offset,
+                                           uint64_t flags);
 
-  return v;
-}
+sd_bus_vtable sdbus_vtable_create_method(const char* member, const char* signature,
+                                         const char* result, sd_bus_message_handler_t handler,
+                                         uint64_t flags);
 
-constexpr sd_bus_vtable method_o(const char* member, const char* signature,
-                                 const char* result,
-                                 sd_bus_message_handler_t handler, size_t offset,
-                                 uint64_t flags) {
-  sd_bus_vtable v{};
-  v.type = _SD_BUS_VTABLE_METHOD;
-  v.flags = flags;
-  v.x.method = decltype(v.x.method){member, signature, result, handler, offset};
+sd_bus_vtable sdbus_vtable_create_signal(const char* member, const char* signature, uint64_t flags);
 
-  return v;
-}
+sd_bus_vtable sdbus_vtable_create_property(const char* member, const char* signature,
+                                           sd_bus_property_get_t get,
+                                           uint64_t flags);
 
-constexpr sd_bus_vtable method(const char* member, const char* signature,
-                               const char* result, sd_bus_message_handler_t handler,
-                               uint64_t flags) {
-    return method_o(member, signature, result, handler, 0, flags);
-}
+sd_bus_vtable sdbus_vtable_create_property_set(const char* member, const char* signature,
+                                               sd_bus_property_get_t get,
+                                               sd_bus_property_set_t set,
+                                               uint64_t flags);
 
-constexpr sd_bus_vtable signal(const char* member, const char* signature, uint64_t flags) {
-  sd_bus_vtable v{};
-  v.type = _SD_BUS_VTABLE_SIGNAL;
-  v.flags = flags;
-  v.x.signal = decltype(v.x.signal){member, signature};
+sd_bus_vtable sdbus_vtable_create_property_o(const char* member, const char* signature,
+                                             size_t offset, uint64_t flags);
 
-  return v;
-}
-
-constexpr sd_bus_vtable property(const char* member, const char* signature,
-                                 sd_bus_property_get_t get,
-                                 uint64_t flags) {
-  sd_bus_vtable v{};
-  v.type = _SD_BUS_VTABLE_PROPERTY;
-  v.flags = flags;
-  v.x.property = decltype(v.x.property){member, signature, get, nullptr, 0};
-
-  return v;
-}
-
-constexpr sd_bus_vtable property(const char* member, const char* signature,
-                                 sd_bus_property_get_t get,
-                                 sd_bus_property_set_t set,
-                                 uint64_t flags) {
-  sd_bus_vtable v{};
-  v.type = _SD_BUS_VTABLE_WRITABLE_PROPERTY;
-  v.flags = flags;
-  v.x.property = decltype(v.x.property){member, signature, get, set, 0};
-
-  return v;
-}
-
-constexpr sd_bus_vtable property_o(const char* member, const char* signature,
-                                   size_t offset, uint64_t flags) {
-  sd_bus_vtable v{};
-  v.type = _SD_BUS_VTABLE_PROPERTY;
-  v.flags = flags;
-  v.x.property = decltype(v.x.property){member, signature, nullptr, nullptr, offset};
-
-  return v;
-}
-
-constexpr sd_bus_vtable property_o(const char* member, const char* signature,
-                                   sd_bus_property_set_t set, size_t offset,
-                                   uint64_t flags)
-{
-  sd_bus_vtable v{};
-  v.type = _SD_BUS_VTABLE_WRITABLE_PROPERTY;
-  v.flags = flags;
-  v.x.property = decltype(v.x.property){member, signature, nullptr, set, offset};
-
-  return v;
-}
-} // namespace vtable
-} // namespace sd_bus
-} // namespace dbus
-} // namespace anbox
+sd_bus_vtable sdbus_vtable_create_property_o_set(const char* member, const char* signature,
+                                                 sd_bus_property_set_t set, size_t offset,
+                                                 uint64_t flags);
 
 #endif

src/anbox/dbus/sd_bus_helpers.hpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2019 Martin Unzner <[email protected]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ANBOX_DBUS_SD_BUS_HELPERS_HPP_
+#define ANBOX_DBUS_SD_BUS_HELPERS_HPP_
+
+namespace anbox {
+namespace dbus {
+
+extern "C" {
+#include "sd_bus_helpers.h"
+}
+}  // namespace dbus
+}  // namespace anbox
+
+#endif

src/anbox/dbus/skeleton/application_manager.cpp

@@ -17,7 +17,7 @@
 
 #include "anbox/dbus/skeleton/application_manager.h"
 #include "anbox/dbus/interface.h"
-#include "anbox/dbus/sd_bus_helpers.h"
+#include "anbox/dbus/sd_bus_helpers.hpp"
 #include "anbox/android/intent.h"
 #include "anbox/logger.h"
 
@@ -51,10 +51,10 @@ namespace anbox {
 namespace dbus {
 namespace skeleton {
 const sd_bus_vtable ApplicationManager::vtable[] = {
-  sdbus::vtable::start(0),
-  sdbus::vtable::method("Launch", "a{sv}s", "", ApplicationManager::method_launch, SD_BUS_VTABLE_UNPRIVILEGED),
-  sdbus::vtable::property("Ready", "b", ApplicationManager::property_ready_get, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
-  sdbus::vtable::end()
+  sdbus_vtable_create_start(0),
+  sdbus_vtable_create_method("Launch", "a{sv}s", "", ApplicationManager::method_launch, SD_BUS_VTABLE_UNPRIVILEGED),
+  sdbus_vtable_create_property("Ready", "b", ApplicationManager::property_ready_get, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+  sdbus_vtable_create_end()
 };
 
 int ApplicationManager::method_launch(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {