Attachment 116196 Details for Bug 90118 – incomplete attempt to enforce sane UTF-8 string in the D-Bus bindings

[patch] incomplete attempt to enforce sane UTF-8 string in the D-Bus bindings

utf8string-dbus.patch (text/plain), 10.97 KB, created by Patrick Ohly on 2015-06-01 08:26:00 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Patrick Ohly

Created: 2015-06-01 08:26:00 UTC

Size: 10.97 KB

patch

obsolete

>diff --git a/src/gdbus/gdbus-cxx-bridge.h b/src/gdbus/gdbus-cxx-bridge.h
>index dbbe219..d11410b 100644
>--- a/src/gdbus/gdbus-cxx-bridge.h
>+++ b/src/gdbus/gdbus-cxx-bridge.h
>@@ -1126,7 +1126,11 @@ template<> struct dbus_traits<bool> : public dbus_traits_base
>     typedef bool arg_type;
> };
> 
>-template<> struct dbus_traits<std::string> : public dbus_traits_base
>+class UTF8String : public std::string
>+{
>+};
>+
>+template<> struct dbus_traits<UTF8String> : public dbus_traits_base
> {
>     static std::string getType() { return "s"; }
>     static std::string getSignature() {return getType(); }
>diff --git a/src/gdbusxx/gdbus-cxx-bridge.h b/src/gdbusxx/gdbus-cxx-bridge.h
>index a373a5c..a4ada18 100644
>--- a/src/gdbusxx/gdbus-cxx-bridge.h
>+++ b/src/gdbusxx/gdbus-cxx-bridge.h
>@@ -426,6 +426,8 @@ class AppendRetvals {
>         dbus_traits<A>::append(m_builder, a);
>         return *this;
>     }
>+
>+    inline AppendRetvals & operator << (const std::string &a);
> };
> 
> /**
>@@ -464,6 +466,14 @@ struct AppendArgs {
>     }
> };
> 
>+/**
>+ * Functions returning std::string are expected to return valid UTF-8
>+ * strings, without a need to declare that explicitly. Done to avoid
>+ * polluting "normal" methods with D-Bus specific annotations.
>+ */
>+template<class R> const R &TransformReturnValue(const R &r) { return r; }
>+const UTF8String &TransformReturnValue(const std::string &r) { return UTF8String::cast(r); }
>+
> /** default: skip it, not a result of the method */
> template<class A> struct Set
> {
>@@ -488,7 +498,7 @@ template<class A> struct Set <A &>
>     typename dbus_traits<A>::host_type &m_a;
>     Set(typename dbus_traits<A>::host_type &a) : m_a(a) {}
>     AppendArgs &set(AppendArgs &context) const {
>-        dbus_traits<A>::append(context.m_builder, m_a);
>+        dbus_traits<A>::append(context.m_builder, TransformReturnValue(m_a));
>         return context;
>     }
> };
>@@ -1511,7 +1521,10 @@ template<> struct dbus_traits<bool> : public dbus_traits_base
>     }
> };
> 
>-template<> struct dbus_traits<std::string> : public dbus_traits_base
>+/**
>+ * A std::string containing UTF8 data can be encoded as-is.
>+ */
>+template<> struct dbus_traits<UTF8String> : public dbus_traits_base
> {
>     static std::string getType() { return "s"; }
>     static std::string getSignature() {return getType(); }
>@@ -1528,7 +1541,7 @@ template<> struct dbus_traits<std::string> : public dbus_traits_base
>         value = str;
>     }
> 
>-    static void append(GVariantBuilder &builder, const std::string &value)
>+    static void append(GVariantBuilder &builder, const UTF8String &value)
>     {
>         g_variant_builder_add_value(&builder, g_variant_new_string(value.c_str()));
>     }
>@@ -1537,6 +1550,59 @@ template<> struct dbus_traits<std::string> : public dbus_traits_base
>     typedef const std::string &arg_type;
> };
> 
>+AppendRetvals & AppendRetvals::operator << (const std::string &a)
>+{
>+    dbus_traits<UTF8String>::append(m_builder, UTF8String::cast(a));
>+    return *this;
>+}
>+
>+/**
>+ * A std::string can be filled from D-Bus, but sending it via
>+ * D-Bus is problematic because the content may or may not be clean
>+ * UTF-8. The caller must know about that and either cast to UTF8String
>+ * or convert the string.
>+ */
>+template<> struct dbus_traits<std::string> : public dbus_traits_base
>+{
>+    static std::string getType() { return "s"; }
>+    static std::string getSignature() {return getType(); }
>+    static std::string getReply() { return ""; }
>+
>+    static void get(ExtractArgs &context,
>+                    GVariantIter &iter, std::string &value)
>+    {
>+        GVariantCXX var(g_variant_iter_next_value(&iter));
>+        if (var == NULL || !g_variant_type_equal(g_variant_get_type(var), G_VARIANT_TYPE_STRING)) {
>+            throw std::runtime_error("g_variant failure " GDBUS_CXX_SOURCE_INFO);
>+        }
>+        const char *str = g_variant_get_string(var, NULL);
>+        value = str;
>+    }
>+
>+    typedef std::string host_type;
>+    typedef const std::string &arg_type;
>+};
>+
>+/**
>+ * String constants are supposed to be valid UTF-8. In practice,
>+ * they are even plain ASCII. Therefore we can convert directly
>+ * without checking and without intermediate conversion to std::string.
>+ */
>+template<> struct dbus_traits<char *> : public dbus_traits_base
>+{
>+    static std::string getType() { return "s"; }
>+    static std::string getSignature() {return getType(); }
>+    static std::string getReply() { return ""; }
>+
>+    static void append(GVariantBuilder &builder, const char *value)
>+    {
>+        g_variant_builder_add_value(&builder, g_variant_new_string(value));
>+    }
>+
>+    typedef std::string host_type;
>+    typedef const std::string &arg_type;
>+};
>+
> template<> struct dbus_traits<const char *> : public dbus_traits_base
> {
>     static std::string getType() { return "s"; }
>@@ -3255,7 +3321,7 @@ struct MakeMethodEntry< boost::function<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)>
>                 }
> 
>                 reply.reset(g_dbus_message_new_method_reply(msg));
>-                AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5)
>+                AppendArgs(reply) + TransformReturnValue(r) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4) << Set<A5>(a5)
>                                       << Set<A6>(a6) << Set<A7>(a7) << Set<A8>(a8) << Set<A9>(a9);
> 
>             } catch (...) {
>@@ -3434,7 +3500,7 @@ struct MakeMethodEntry< boost::function<R (A1, A2, A3, A4, A5, A6, A7, A8)> >
>                 }
> 
>                 reply.reset(g_dbus_message_new_method_reply(msg));
>-                AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4)
>+                AppendArgs(reply) + TransformReturnValue(r) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4)
>                                       << Set<A5>(a5) << Set<A6>(a6) << Set<A7>(a7) << Set<A8>(a8);
> 
>             } catch (...) {
>@@ -3607,7 +3673,7 @@ struct MakeMethodEntry< boost::function<R (A1, A2, A3, A4, A5, A6, A7)> >
>                 }
> 
>                 reply.reset(g_dbus_message_new_method_reply(msg));
>-                AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4)
>+                AppendArgs(reply) + TransformReturnValue(r) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4)
>                                       << Set<A5>(a5) << Set<A6>(a6) << Set<A7>(a7);
>             } catch (...) {
>                 return handleException(msg);
>@@ -3773,7 +3839,7 @@ struct MakeMethodEntry< boost::function<R (A1, A2, A3, A4, A5, A6)> >
>                 }
> 
>                 reply.reset(g_dbus_message_new_method_reply(msg));
>-                AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3)
>+                AppendArgs(reply) + TransformReturnValue(r) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3)
>                                       << Set<A4>(a4) << Set<A5>(a5) << Set<A6>(a6);
> 
>             } catch (...) {
>@@ -3933,7 +3999,7 @@ struct MakeMethodEntry< boost::function<R (A1, A2, A3, A4, A5)> >
>                 }
> 
>                 reply.reset(g_dbus_message_new_method_reply(msg));
>-                AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3)
>+                AppendArgs(reply) + TransformReturnValue(r) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3)
>                                       << Set<A4>(a4) << Set<A5>(a5);
>             } catch (...) {
>                 return handleException(msg);
>@@ -4084,7 +4150,7 @@ struct MakeMethodEntry< boost::function<R (A1, A2, A3, A4)> >
>                 }
> 
>                 reply.reset(g_dbus_message_new_method_reply(msg));
>-                AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4);
>+                AppendArgs(reply) + TransformReturnValue(r) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3) << Set<A4>(a4);
>             } catch (...) {
>                 return handleException(msg);
>             }
>@@ -4226,7 +4292,7 @@ struct MakeMethodEntry< boost::function<R (A1, A2, A3)> >
>                 }
> 
>                 reply.reset(g_dbus_message_new_method_reply(msg));
>-                AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3);
>+                AppendArgs(reply) + TransformReturnValue(r) << Set<A1>(a1) << Set<A2>(a2) << Set<A3>(a3);
>             } catch (...) {
>                 return handleException(msg);
>             }
>@@ -4362,7 +4428,7 @@ struct MakeMethodEntry< boost::function<R (A1, A2)> >
>                 }
> 
>                 reply.reset(g_dbus_message_new_method_reply(msg));
>-                AppendArgs(reply) + r << Set<A1>(a1) << Set<A2>(a2);
>+                AppendArgs(reply) + TransformReturnValue(r) << Set<A1>(a1) << Set<A2>(a2);
>             } catch (...) {
>                 return handleException(msg);
>             }
>@@ -4492,7 +4558,7 @@ struct MakeMethodEntry< boost::function<R (A1)> >
>                 }
> 
>                 reply.reset(g_dbus_message_new_method_reply(msg));
>-                AppendArgs(reply) + r << Set<A1>(a1);
>+                AppendArgs(reply) + TransformReturnValue(r) << Set<A1>(a1);
>             } catch (...) {
>                 return handleException(msg);
>             }
>@@ -4607,7 +4673,7 @@ struct MakeMethodEntry< boost::function<R ()> >
>                 r = (*static_cast<M *>(data))();
> 
>                 reply.reset(g_dbus_message_new_method_reply(msg));
>-                AppendArgs(reply) + r;
>+                AppendArgs(reply) + TransformReturnValue(r);
>             } catch (...) {
>                 return handleException(msg);
>             }
>@@ -5339,7 +5405,7 @@ template <class T> class SignalWatch : public SignalFilter
>                                                            "/org/freedesktop/DBus",
>                                                            "org.freedesktop.DBus",
>                                                            "org.freedesktop.DBus"),
>-                                "RemoveMatch")(m_matchRule);
>+                                "RemoveMatch")(GDBusCXX::UTF8String::cast(m_matchRule));
>             }
>         } catch (...) {
>             // TODO (?): log error
>@@ -5389,7 +5455,7 @@ template <class T> class SignalWatch : public SignalFilter
>                                                        "/org/freedesktop/DBus",
>                                                        "org.freedesktop.DBus",
>                                                        "org.freedesktop.DBus"),
>-                            "AddMatch")(m_matchRule);
>+                            "AddMatch")(GDBusCXX::UTF8String::cast(m_matchRule));
>             m_manualMatch = true;
>         }
>     }
>diff --git a/src/gdbusxx/gdbus-cxx.h b/src/gdbusxx/gdbus-cxx.h
>index a8f3156..0fa7c7a 100644
>--- a/src/gdbusxx/gdbus-cxx.h
>+++ b/src/gdbusxx/gdbus-cxx.h
>@@ -202,6 +202,12 @@ struct Result10 : virtual public Result
>     virtual void done(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) = 0;
> };
> 
>+class UTF8String : public std::string
>+{
>+ public:
>+    static const UTF8String &cast(const std::string &utf8stdstring) { return static_cast<const UTF8String &>(utf8stdstring); }
>+};
>+
> } // namespace GDBusCXX
> 
> #endif // INCL_GDBUS_CXX

Actions: View | Splinter Review

Attachments on bug 90118: 115231 | 115232 | 116196

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.