Adding upstream version 2.9.4.upstream/2.9.4

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

23 files changed, 11269 insertions, 0 deletions

diff --git a/src/sss_iface/external_iface.xml b/src/sss_iface/external_iface.xml
new file mode 100644
index 0000000..387f198
--- /dev/null
+++ b/src/sss_iface/external_iface.xml
@@ -0,0 +1,32 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+    <interface name="org.freedesktop.systemd1.Manager">
+        <annotation name="codegen.Name" value="systemd" />
+        <annotation name="codegen.AsyncCaller" value="false" />
+        <method name="StartUnit">
+            <arg type="s" name="name" direction="in" />
+            <arg type="s" name="mode" direction="in" />
+            <arg type="o" name="job" direction="out" />
+        </method>
+        <method name="StopUnit">
+            <arg type="s" name="name" direction="in" />
+            <arg type="s" name="mode" direction="in" />
+            <arg type="o" name="job" direction="out" />
+        </method>
+        <method name="RestartUnit">
+            <arg type="s" name="name" direction="in" />
+            <arg type="s" name="mode" direction="in" />
+            <arg type="o" name="job" direction="out" />
+        </method>
+    </interface>
+    <interface name="org.freedesktop.FleetCommanderClient">
+        <annotation name="codegen.Name" value="fleet" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="ProcessSSSDFiles">
+            <arg type="u" name="uid" direction="in" />
+            <arg type="s" name="user_dir" direction="in" />
+            <arg type="q" name="prio" direction="in" />
+        </method>
+    </interface>
+</node>
diff --git a/src/sss_iface/sbus_sss_arguments.c b/src/sss_iface/sbus_sss_arguments.c
new file mode 100644
index 0000000..14d705b
--- /dev/null
+++ b/src/sss_iface/sbus_sss_arguments.c
@@ -0,0 +1,810 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 <errno.h>
+#include <stdint.h>
+#include <talloc.h>
+#include <stdbool.h>
+#include <dbus/dbus.h>
+
+#include "sbus/interface/sbus_iterator_readers.h"
+#include "sbus/interface/sbus_iterator_writers.h"
+#include "sss_iface/sbus_sss_arguments.h"
+
+errno_t _sbus_sss_invoker_read_as
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_as *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_as(mem_ctx, iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_as
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_as *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_as(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_b
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_b *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_b(iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_b
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_b *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_b(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_o
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_o *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_o(mem_ctx, iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_o
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_o *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_o(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_pam_data
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_pam_data *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_pam_data(mem_ctx, iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_pam_data
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_pam_data *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_pam_data(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_pam_response
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_pam_response *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_pam_response(mem_ctx, iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_pam_response
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_pam_response *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_pam_response(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_q
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_q *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_q(iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_q
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_q *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_q(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_qus
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_qus *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_q(iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_u(iter, &args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_qus
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_qus *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_q(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_u(iter, args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_s
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_s *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_s
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_s *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_s(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_sqq
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_sqq *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_q(iter, &args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_q(iter, &args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_sqq
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_sqq *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_s(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_q(iter, args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_q(iter, args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_ss
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ss *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_ss
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ss *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_s(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_ssau
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ssau *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_au(mem_ctx, iter, &args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_ssau
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ssau *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_s(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_au(iter, args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_u
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_u *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_u(iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_u
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_u *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_u(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_usq
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_usq *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_u(iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_q(iter, &args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_usq
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_usq *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_u(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_q(iter, args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_ussu
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ussu *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_u(iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_u(iter, &args->arg3);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_ussu
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ussu *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_u(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_u(iter, args->arg3);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_usu
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_usu *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_u(iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_u(iter, &args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_usu
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_usu *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_u(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_u(iter, args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_uusssu
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uusssu *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_u(iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_u(iter, &args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg3);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg4);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_u(iter, &args->arg5);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_uusssu
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uusssu *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_u(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_u(iter, args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg3);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg4);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_u(iter, args->arg5);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_uusu
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uusu *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_u(iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_u(iter, &args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_u(iter, &args->arg3);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_uusu
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uusu *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_u(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_u(iter, args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_u(iter, args->arg3);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_read_uuusu
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uuusu *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_read_u(iter, &args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_u(iter, &args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_u(iter, &args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg3);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_read_u(iter, &args->arg4);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
+
+errno_t _sbus_sss_invoker_write_uuusu
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uuusu *args)
+{
+    errno_t ret;
+
+    ret = sbus_iterator_write_u(iter, args->arg0);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_u(iter, args->arg1);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_u(iter, args->arg2);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_s(iter, args->arg3);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    ret = sbus_iterator_write_u(iter, args->arg4);
+    if (ret != EOK) {
+        return ret;
+    }
+
+    return EOK;
+}
diff --git a/src/sss_iface/sbus_sss_arguments.h b/src/sss_iface/sbus_sss_arguments.h
new file mode 100644
index 0000000..41067aa
--- /dev/null
+++ b/src/sss_iface/sbus_sss_arguments.h
@@ -0,0 +1,327 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SBUS_SSS_ARGUMENTS_H_
+#define _SBUS_SSS_ARGUMENTS_H_
+
+#include <errno.h>
+#include <stdint.h>
+#include <talloc.h>
+#include <stdbool.h>
+#include <dbus/dbus.h>
+
+#include "sss_iface/sss_iface_types.h"
+
+struct _sbus_sss_invoker_args_as {
+    const char ** arg0;
+};
+
+errno_t
+_sbus_sss_invoker_read_as
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_as *args);
+
+errno_t
+_sbus_sss_invoker_write_as
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_as *args);
+
+struct _sbus_sss_invoker_args_b {
+    bool arg0;
+};
+
+errno_t
+_sbus_sss_invoker_read_b
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_b *args);
+
+errno_t
+_sbus_sss_invoker_write_b
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_b *args);
+
+struct _sbus_sss_invoker_args_o {
+    const char * arg0;
+};
+
+errno_t
+_sbus_sss_invoker_read_o
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_o *args);
+
+errno_t
+_sbus_sss_invoker_write_o
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_o *args);
+
+struct _sbus_sss_invoker_args_pam_data {
+    struct pam_data * arg0;
+};
+
+errno_t
+_sbus_sss_invoker_read_pam_data
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_pam_data *args);
+
+errno_t
+_sbus_sss_invoker_write_pam_data
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_pam_data *args);
+
+struct _sbus_sss_invoker_args_pam_response {
+    struct pam_data * arg0;
+};
+
+errno_t
+_sbus_sss_invoker_read_pam_response
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_pam_response *args);
+
+errno_t
+_sbus_sss_invoker_write_pam_response
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_pam_response *args);
+
+struct _sbus_sss_invoker_args_q {
+    uint16_t arg0;
+};
+
+errno_t
+_sbus_sss_invoker_read_q
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_q *args);
+
+errno_t
+_sbus_sss_invoker_write_q
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_q *args);
+
+struct _sbus_sss_invoker_args_qus {
+    uint16_t arg0;
+    uint32_t arg1;
+    const char * arg2;
+};
+
+errno_t
+_sbus_sss_invoker_read_qus
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_qus *args);
+
+errno_t
+_sbus_sss_invoker_write_qus
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_qus *args);
+
+struct _sbus_sss_invoker_args_s {
+    const char * arg0;
+};
+
+errno_t
+_sbus_sss_invoker_read_s
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_s *args);
+
+errno_t
+_sbus_sss_invoker_write_s
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_s *args);
+
+struct _sbus_sss_invoker_args_sqq {
+    const char * arg0;
+    uint16_t arg1;
+    uint16_t arg2;
+};
+
+errno_t
+_sbus_sss_invoker_read_sqq
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_sqq *args);
+
+errno_t
+_sbus_sss_invoker_write_sqq
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_sqq *args);
+
+struct _sbus_sss_invoker_args_ss {
+    const char * arg0;
+    const char * arg1;
+};
+
+errno_t
+_sbus_sss_invoker_read_ss
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ss *args);
+
+errno_t
+_sbus_sss_invoker_write_ss
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ss *args);
+
+struct _sbus_sss_invoker_args_ssau {
+    const char * arg0;
+    const char * arg1;
+    uint32_t * arg2;
+};
+
+errno_t
+_sbus_sss_invoker_read_ssau
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ssau *args);
+
+errno_t
+_sbus_sss_invoker_write_ssau
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ssau *args);
+
+struct _sbus_sss_invoker_args_u {
+    uint32_t arg0;
+};
+
+errno_t
+_sbus_sss_invoker_read_u
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_u *args);
+
+errno_t
+_sbus_sss_invoker_write_u
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_u *args);
+
+struct _sbus_sss_invoker_args_usq {
+    uint32_t arg0;
+    const char * arg1;
+    uint16_t arg2;
+};
+
+errno_t
+_sbus_sss_invoker_read_usq
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_usq *args);
+
+errno_t
+_sbus_sss_invoker_write_usq
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_usq *args);
+
+struct _sbus_sss_invoker_args_ussu {
+    uint32_t arg0;
+    const char * arg1;
+    const char * arg2;
+    uint32_t arg3;
+};
+
+errno_t
+_sbus_sss_invoker_read_ussu
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ussu *args);
+
+errno_t
+_sbus_sss_invoker_write_ussu
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_ussu *args);
+
+struct _sbus_sss_invoker_args_usu {
+    uint32_t arg0;
+    const char * arg1;
+    uint32_t arg2;
+};
+
+errno_t
+_sbus_sss_invoker_read_usu
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_usu *args);
+
+errno_t
+_sbus_sss_invoker_write_usu
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_usu *args);
+
+struct _sbus_sss_invoker_args_uusssu {
+    uint32_t arg0;
+    uint32_t arg1;
+    const char * arg2;
+    const char * arg3;
+    const char * arg4;
+    uint32_t arg5;
+};
+
+errno_t
+_sbus_sss_invoker_read_uusssu
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uusssu *args);
+
+errno_t
+_sbus_sss_invoker_write_uusssu
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uusssu *args);
+
+struct _sbus_sss_invoker_args_uusu {
+    uint32_t arg0;
+    uint32_t arg1;
+    const char * arg2;
+    uint32_t arg3;
+};
+
+errno_t
+_sbus_sss_invoker_read_uusu
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uusu *args);
+
+errno_t
+_sbus_sss_invoker_write_uusu
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uusu *args);
+
+struct _sbus_sss_invoker_args_uuusu {
+    uint32_t arg0;
+    uint32_t arg1;
+    uint32_t arg2;
+    const char * arg3;
+    uint32_t arg4;
+};
+
+errno_t
+_sbus_sss_invoker_read_uuusu
+   (TALLOC_CTX *mem_ctx,
+    DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uuusu *args);
+
+errno_t
+_sbus_sss_invoker_write_uuusu
+   (DBusMessageIter *iter,
+    struct _sbus_sss_invoker_args_uuusu *args);
+
+#endif /* _SBUS_SSS_ARGUMENTS_H_ */
diff --git a/src/sss_iface/sbus_sss_client_async.c b/src/sss_iface/sbus_sss_client_async.c
new file mode 100644
index 0000000..5ca9252
--- /dev/null
+++ b/src/sss_iface/sbus_sss_client_async.c
@@ -0,0 +1,2545 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 <errno.h>
+#include <talloc.h>
+#include <tevent.h>
+#include <dbus/dbus.h>
+
+#include "sbus/sbus_private.h"
+#include "sbus/interface/sbus_iterator_readers.h"
+#include "sbus/interface_dbus/sbus_dbus_client_async.h"
+#include "sss_iface/sbus_sss_arguments.h"
+#include "sss_iface/sbus_sss_keygens.h"
+#include "sss_iface/sbus_sss_client_properties.h"
+
+struct sbus_method_in__out__state {
+    int dummy;
+};
+
+static void sbus_method_in__out__done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in__out__send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method)
+{
+    struct sbus_method_in__out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in__out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen, NULL,
+                                   bus, path, iface, method, NULL);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in__out__done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in__out__done(struct tevent_req *subreq)
+{
+    struct sbus_method_in__out__state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in__out__state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in__out__recv
+    (struct tevent_req *req)
+{
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    return EOK;
+}
+
+struct sbus_method_in_pam_data_out_pam_response_state {
+    struct _sbus_sss_invoker_args_pam_data in;
+    struct _sbus_sss_invoker_args_pam_response *out;
+};
+
+static void sbus_method_in_pam_data_out_pam_response_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_pam_data_out_pam_response_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     struct pam_data * arg0)
+{
+    struct sbus_method_in_pam_data_out_pam_response_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_pam_data_out_pam_response_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_pam_response);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    state->in.arg0 = arg0;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_pam_data,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_pam_data_out_pam_response_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_pam_data_out_pam_response_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_pam_data_out_pam_response_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_pam_data_out_pam_response_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_pam_response, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_pam_data_out_pam_response_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     struct pam_data ** _arg0)
+{
+    struct sbus_method_in_pam_data_out_pam_response_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_pam_data_out_pam_response_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = talloc_steal(mem_ctx, state->out->arg0);
+
+    return EOK;
+}
+
+struct sbus_method_in_raw_out_qus_state {
+    struct _sbus_sss_invoker_args_qus *out;
+};
+
+static void sbus_method_in_raw_out_qus_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_raw_out_qus_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     DBusMessage *raw_message)
+{
+    struct sbus_method_in_raw_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_raw_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_qus);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+
+    subreq = sbus_call_method_send(state, conn, raw_message, NULL, NULL, NULL,
+                                   dbus_message_get_path(raw_message),
+                                   dbus_message_get_interface(raw_message),
+                                   dbus_message_get_member(raw_message), NULL);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_raw_out_qus_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_raw_out_qus_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_raw_out_qus_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_raw_out_qus_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_qus, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_raw_out_qus_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _arg0,
+     uint32_t* _arg1,
+     const char ** _arg2)
+{
+    struct sbus_method_in_raw_out_qus_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_raw_out_qus_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = state->out->arg0;
+    *_arg1 = state->out->arg1;
+    *_arg2 = talloc_steal(mem_ctx, state->out->arg2);
+
+    return EOK;
+}
+
+struct sbus_method_in_s_out__state {
+    struct _sbus_sss_invoker_args_s in;
+};
+
+static void sbus_method_in_s_out__done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_s_out__send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     const char * arg0)
+{
+    struct sbus_method_in_s_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_s_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->in.arg0 = arg0;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_s,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_s_out__done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_s_out__done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_s_out__state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_s_out__state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_s_out__recv
+    (struct tevent_req *req)
+{
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    return EOK;
+}
+
+struct sbus_method_in_s_out_as_state {
+    struct _sbus_sss_invoker_args_s in;
+    struct _sbus_sss_invoker_args_as *out;
+};
+
+static void sbus_method_in_s_out_as_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_s_out_as_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     const char * arg0)
+{
+    struct sbus_method_in_s_out_as_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_s_out_as_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_as);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    state->in.arg0 = arg0;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_s,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_s_out_as_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_s_out_as_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_s_out_as_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_s_out_as_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_as, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_s_out_as_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     const char *** _arg0)
+{
+    struct sbus_method_in_s_out_as_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_s_out_as_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = talloc_steal(mem_ctx, state->out->arg0);
+
+    return EOK;
+}
+
+struct sbus_method_in_s_out_b_state {
+    struct _sbus_sss_invoker_args_s in;
+    struct _sbus_sss_invoker_args_b *out;
+};
+
+static void sbus_method_in_s_out_b_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_s_out_b_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     const char * arg0)
+{
+    struct sbus_method_in_s_out_b_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_s_out_b_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_b);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    state->in.arg0 = arg0;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_s,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_s_out_b_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_s_out_b_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_s_out_b_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_s_out_b_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_b, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_s_out_b_recv
+    (struct tevent_req *req,
+     bool* _arg0)
+{
+    struct sbus_method_in_s_out_b_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_s_out_b_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = state->out->arg0;
+
+    return EOK;
+}
+
+struct sbus_method_in_s_out_qus_state {
+    struct _sbus_sss_invoker_args_s in;
+    struct _sbus_sss_invoker_args_qus *out;
+};
+
+static void sbus_method_in_s_out_qus_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_s_out_qus_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     const char * arg0)
+{
+    struct sbus_method_in_s_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_s_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_qus);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    state->in.arg0 = arg0;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_s,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_s_out_qus_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_s_out_qus_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_s_out_qus_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_s_out_qus_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_qus, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_s_out_qus_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _arg0,
+     uint32_t* _arg1,
+     const char ** _arg2)
+{
+    struct sbus_method_in_s_out_qus_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_s_out_qus_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = state->out->arg0;
+    *_arg1 = state->out->arg1;
+    *_arg2 = talloc_steal(mem_ctx, state->out->arg2);
+
+    return EOK;
+}
+
+struct sbus_method_in_s_out_s_state {
+    struct _sbus_sss_invoker_args_s in;
+    struct _sbus_sss_invoker_args_s *out;
+};
+
+static void sbus_method_in_s_out_s_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_s_out_s_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     const char * arg0)
+{
+    struct sbus_method_in_s_out_s_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_s_out_s_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_s);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    state->in.arg0 = arg0;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_s,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_s_out_s_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_s_out_s_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_s_out_s_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_s_out_s_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_s, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_s_out_s_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     const char ** _arg0)
+{
+    struct sbus_method_in_s_out_s_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_s_out_s_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = talloc_steal(mem_ctx, state->out->arg0);
+
+    return EOK;
+}
+
+struct sbus_method_in_sqq_out_q_state {
+    struct _sbus_sss_invoker_args_sqq in;
+    struct _sbus_sss_invoker_args_q *out;
+};
+
+static void sbus_method_in_sqq_out_q_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_sqq_out_q_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     const char * arg0,
+     uint16_t arg1,
+     uint16_t arg2)
+{
+    struct sbus_method_in_sqq_out_q_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_sqq_out_q_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_q);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    state->in.arg0 = arg0;
+    state->in.arg1 = arg1;
+    state->in.arg2 = arg2;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_sqq,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_sqq_out_q_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_sqq_out_q_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_sqq_out_q_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_sqq_out_q_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_q, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_sqq_out_q_recv
+    (struct tevent_req *req,
+     uint16_t* _arg0)
+{
+    struct sbus_method_in_sqq_out_q_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_sqq_out_q_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = state->out->arg0;
+
+    return EOK;
+}
+
+struct sbus_method_in_ssau_out__state {
+    struct _sbus_sss_invoker_args_ssau in;
+};
+
+static void sbus_method_in_ssau_out__done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_ssau_out__send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     const char * arg0,
+     const char * arg1,
+     uint32_t * arg2)
+{
+    struct sbus_method_in_ssau_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_ssau_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->in.arg0 = arg0;
+    state->in.arg1 = arg1;
+    state->in.arg2 = arg2;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_ssau,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_ssau_out__done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_ssau_out__done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_ssau_out__state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_ssau_out__state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_ssau_out__recv
+    (struct tevent_req *req)
+{
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    return EOK;
+}
+
+struct sbus_method_in_u_out__state {
+    struct _sbus_sss_invoker_args_u in;
+};
+
+static void sbus_method_in_u_out__done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_u_out__send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     uint32_t arg0)
+{
+    struct sbus_method_in_u_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_u_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->in.arg0 = arg0;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_u,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_u_out__done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_u_out__done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_u_out__state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_u_out__state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_u_out__recv
+    (struct tevent_req *req)
+{
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    return EOK;
+}
+
+struct sbus_method_in_usq_out__state {
+    struct _sbus_sss_invoker_args_usq in;
+};
+
+static void sbus_method_in_usq_out__done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_usq_out__send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     uint32_t arg0,
+     const char * arg1,
+     uint16_t arg2)
+{
+    struct sbus_method_in_usq_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_usq_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->in.arg0 = arg0;
+    state->in.arg1 = arg1;
+    state->in.arg2 = arg2;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_usq,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_usq_out__done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_usq_out__done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_usq_out__state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_usq_out__state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_usq_out__recv
+    (struct tevent_req *req)
+{
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    return EOK;
+}
+
+struct sbus_method_in_ussu_out__state {
+    struct _sbus_sss_invoker_args_ussu in;
+};
+
+static void sbus_method_in_ussu_out__done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_ussu_out__send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     uint32_t arg0,
+     const char * arg1,
+     const char * arg2,
+     uint32_t arg3)
+{
+    struct sbus_method_in_ussu_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_ussu_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->in.arg0 = arg0;
+    state->in.arg1 = arg1;
+    state->in.arg2 = arg2;
+    state->in.arg3 = arg3;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_ussu,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_ussu_out__done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_ussu_out__done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_ussu_out__state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_ussu_out__state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_ussu_out__recv
+    (struct tevent_req *req)
+{
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    return EOK;
+}
+
+struct sbus_method_in_ussu_out_qus_state {
+    struct _sbus_sss_invoker_args_ussu in;
+    struct _sbus_sss_invoker_args_qus *out;
+};
+
+static void sbus_method_in_ussu_out_qus_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_ussu_out_qus_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     uint32_t arg0,
+     const char * arg1,
+     const char * arg2,
+     uint32_t arg3)
+{
+    struct sbus_method_in_ussu_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_ussu_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_qus);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    state->in.arg0 = arg0;
+    state->in.arg1 = arg1;
+    state->in.arg2 = arg2;
+    state->in.arg3 = arg3;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_ussu,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_ussu_out_qus_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_ussu_out_qus_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_ussu_out_qus_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_ussu_out_qus_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_qus, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_ussu_out_qus_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _arg0,
+     uint32_t* _arg1,
+     const char ** _arg2)
+{
+    struct sbus_method_in_ussu_out_qus_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_ussu_out_qus_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = state->out->arg0;
+    *_arg1 = state->out->arg1;
+    *_arg2 = talloc_steal(mem_ctx, state->out->arg2);
+
+    return EOK;
+}
+
+struct sbus_method_in_usu_out__state {
+    struct _sbus_sss_invoker_args_usu in;
+};
+
+static void sbus_method_in_usu_out__done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_usu_out__send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     uint32_t arg0,
+     const char * arg1,
+     uint32_t arg2)
+{
+    struct sbus_method_in_usu_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_usu_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->in.arg0 = arg0;
+    state->in.arg1 = arg1;
+    state->in.arg2 = arg2;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_usu,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_usu_out__done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_usu_out__done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_usu_out__state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_usu_out__state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_usu_out__recv
+    (struct tevent_req *req)
+{
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    return EOK;
+}
+
+struct sbus_method_in_uusssu_out_qus_state {
+    struct _sbus_sss_invoker_args_uusssu in;
+    struct _sbus_sss_invoker_args_qus *out;
+};
+
+static void sbus_method_in_uusssu_out_qus_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_uusssu_out_qus_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     uint32_t arg0,
+     uint32_t arg1,
+     const char * arg2,
+     const char * arg3,
+     const char * arg4,
+     uint32_t arg5)
+{
+    struct sbus_method_in_uusssu_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_uusssu_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_qus);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    state->in.arg0 = arg0;
+    state->in.arg1 = arg1;
+    state->in.arg2 = arg2;
+    state->in.arg3 = arg3;
+    state->in.arg4 = arg4;
+    state->in.arg5 = arg5;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_uusssu,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_uusssu_out_qus_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_uusssu_out_qus_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_uusssu_out_qus_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_uusssu_out_qus_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_qus, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_uusssu_out_qus_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _arg0,
+     uint32_t* _arg1,
+     const char ** _arg2)
+{
+    struct sbus_method_in_uusssu_out_qus_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_uusssu_out_qus_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = state->out->arg0;
+    *_arg1 = state->out->arg1;
+    *_arg2 = talloc_steal(mem_ctx, state->out->arg2);
+
+    return EOK;
+}
+
+struct sbus_method_in_uusu_out_qus_state {
+    struct _sbus_sss_invoker_args_uusu in;
+    struct _sbus_sss_invoker_args_qus *out;
+};
+
+static void sbus_method_in_uusu_out_qus_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_uusu_out_qus_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     uint32_t arg0,
+     uint32_t arg1,
+     const char * arg2,
+     uint32_t arg3)
+{
+    struct sbus_method_in_uusu_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_uusu_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_qus);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    state->in.arg0 = arg0;
+    state->in.arg1 = arg1;
+    state->in.arg2 = arg2;
+    state->in.arg3 = arg3;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_uusu,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_uusu_out_qus_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_uusu_out_qus_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_uusu_out_qus_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_uusu_out_qus_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_qus, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_uusu_out_qus_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _arg0,
+     uint32_t* _arg1,
+     const char ** _arg2)
+{
+    struct sbus_method_in_uusu_out_qus_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_uusu_out_qus_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = state->out->arg0;
+    *_arg1 = state->out->arg1;
+    *_arg2 = talloc_steal(mem_ctx, state->out->arg2);
+
+    return EOK;
+}
+
+struct sbus_method_in_uuusu_out_qus_state {
+    struct _sbus_sss_invoker_args_uuusu in;
+    struct _sbus_sss_invoker_args_qus *out;
+};
+
+static void sbus_method_in_uuusu_out_qus_done(struct tevent_req *subreq);
+
+static struct tevent_req *
+sbus_method_in_uuusu_out_qus_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     sbus_invoker_keygen keygen,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     uint32_t arg0,
+     uint32_t arg1,
+     uint32_t arg2,
+     const char * arg3,
+     uint32_t arg4)
+{
+    struct sbus_method_in_uuusu_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct sbus_method_in_uuusu_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->out = talloc_zero(state, struct _sbus_sss_invoker_args_qus);
+    if (state->out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    state->in.arg0 = arg0;
+    state->in.arg1 = arg1;
+    state->in.arg2 = arg2;
+    state->in.arg3 = arg3;
+    state->in.arg4 = arg4;
+
+    subreq = sbus_call_method_send(state, conn, NULL, keygen,
+                                   (sbus_invoker_writer_fn)_sbus_sss_invoker_write_uuusu,
+                                   bus, path, iface, method, &state->in);
+    if (subreq == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(subreq, sbus_method_in_uuusu_out_qus_done, req);
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, conn->ev);
+    }
+
+    return req;
+}
+
+static void sbus_method_in_uuusu_out_qus_done(struct tevent_req *subreq)
+{
+    struct sbus_method_in_uuusu_out_qus_state *state;
+    struct tevent_req *req;
+    DBusMessage *reply;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct sbus_method_in_uuusu_out_qus_state);
+
+    ret = sbus_call_method_recv(state, subreq, &reply);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = sbus_read_output(state->out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_qus, state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+static errno_t
+sbus_method_in_uuusu_out_qus_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _arg0,
+     uint32_t* _arg1,
+     const char ** _arg2)
+{
+    struct sbus_method_in_uuusu_out_qus_state *state;
+    state = tevent_req_data(req, struct sbus_method_in_uuusu_out_qus_state);
+
+    TEVENT_REQ_RETURN_ON_ERROR(req);
+
+    *_arg0 = state->out->arg0;
+    *_arg1 = state->out->arg1;
+    *_arg2 = talloc_steal(mem_ctx, state->out->arg2);
+
+    return EOK;
+}
+
+struct tevent_req *
+sbus_call_fleet_ProcessSSSDFiles_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_uid,
+     const char * arg_user_dir,
+     uint16_t arg_prio)
+{
+    return sbus_method_in_usq_out__send(mem_ctx, conn, NULL,
+        busname, object_path, "org.freedesktop.FleetCommanderClient", "ProcessSSSDFiles", arg_uid, arg_user_dir, arg_prio);
+}
+
+errno_t
+sbus_call_fleet_ProcessSSSDFiles_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in_usq_out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_dp_access_RefreshRules_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, _sbus_sss_key_,
+        busname, object_path, "sssd.DataProvider.AccessControl", "RefreshRules");
+}
+
+errno_t
+sbus_call_dp_access_RefreshRules_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_dp_autofs_Enumerate_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     const char * arg_mapname,
+     uint32_t arg_cli_id)
+{
+    return sbus_method_in_usu_out__send(mem_ctx, conn, _sbus_sss_key_usu_0_1,
+        busname, object_path, "sssd.DataProvider.Autofs", "Enumerate", arg_dp_flags, arg_mapname, arg_cli_id);
+}
+
+errno_t
+sbus_call_dp_autofs_Enumerate_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in_usu_out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_dp_autofs_GetEntry_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     const char * arg_mapname,
+     const char * arg_entryname,
+     uint32_t arg_cli_id)
+{
+    return sbus_method_in_ussu_out__send(mem_ctx, conn, _sbus_sss_key_ussu_0_1_2,
+        busname, object_path, "sssd.DataProvider.Autofs", "GetEntry", arg_dp_flags, arg_mapname, arg_entryname, arg_cli_id);
+}
+
+errno_t
+sbus_call_dp_autofs_GetEntry_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in_ussu_out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_dp_autofs_GetMap_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     const char * arg_mapname,
+     uint32_t arg_cli_id)
+{
+    return sbus_method_in_usu_out__send(mem_ctx, conn, _sbus_sss_key_usu_0_1,
+        busname, object_path, "sssd.DataProvider.Autofs", "GetMap", arg_dp_flags, arg_mapname, arg_cli_id);
+}
+
+errno_t
+sbus_call_dp_autofs_GetMap_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in_usu_out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_dp_backend_IsOnline_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_domain_name)
+{
+    return sbus_method_in_s_out_b_send(mem_ctx, conn, _sbus_sss_key_s_0,
+        busname, object_path, "sssd.DataProvider.Backend", "IsOnline", arg_domain_name);
+}
+
+errno_t
+sbus_call_dp_backend_IsOnline_recv
+    (struct tevent_req *req,
+     bool* _status)
+{
+    return sbus_method_in_s_out_b_recv(req, _status);
+}
+
+struct tevent_req *
+sbus_call_dp_client_Register_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_Name)
+{
+    return sbus_method_in_s_out__send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.DataProvider.Client", "Register", arg_Name);
+}
+
+errno_t
+sbus_call_dp_client_Register_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in_s_out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_dp_failover_ActiveServer_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_service_name)
+{
+    return sbus_method_in_s_out_s_send(mem_ctx, conn, _sbus_sss_key_s_0,
+        busname, object_path, "sssd.DataProvider.Failover", "ActiveServer", arg_service_name);
+}
+
+errno_t
+sbus_call_dp_failover_ActiveServer_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     const char ** _server)
+{
+    return sbus_method_in_s_out_s_recv(mem_ctx, req, _server);
+}
+
+struct tevent_req *
+sbus_call_dp_failover_ListServers_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_service_name)
+{
+    return sbus_method_in_s_out_as_send(mem_ctx, conn, _sbus_sss_key_s_0,
+        busname, object_path, "sssd.DataProvider.Failover", "ListServers", arg_service_name);
+}
+
+errno_t
+sbus_call_dp_failover_ListServers_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     const char *** _servers)
+{
+    return sbus_method_in_s_out_as_recv(mem_ctx, req, _servers);
+}
+
+struct tevent_req *
+sbus_call_dp_failover_ListServices_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_domain_name)
+{
+    return sbus_method_in_s_out_as_send(mem_ctx, conn, _sbus_sss_key_s_0,
+        busname, object_path, "sssd.DataProvider.Failover", "ListServices", arg_domain_name);
+}
+
+errno_t
+sbus_call_dp_failover_ListServices_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     const char *** _services)
+{
+    return sbus_method_in_s_out_as_recv(mem_ctx, req, _services);
+}
+
+struct tevent_req *
+sbus_call_proxy_auth_PAM_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     struct pam_data * arg_pam_data)
+{
+    return sbus_method_in_pam_data_out_pam_response_send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.ProxyChild.Auth", "PAM", arg_pam_data);
+}
+
+errno_t
+sbus_call_proxy_auth_PAM_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     struct pam_data ** _pam_response)
+{
+    return sbus_method_in_pam_data_out_pam_response_recv(mem_ctx, req, _pam_response);
+}
+
+struct tevent_req *
+sbus_call_proxy_client_Register_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_ID)
+{
+    return sbus_method_in_u_out__send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.ProxyChild.Client", "Register", arg_ID);
+}
+
+errno_t
+sbus_call_proxy_client_Register_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in_u_out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_resp_domain_SetActive_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name)
+{
+    return sbus_method_in_s_out__send(mem_ctx, conn, _sbus_sss_key_s_0,
+        busname, object_path, "sssd.Responder.Domain", "SetActive", arg_name);
+}
+
+errno_t
+sbus_call_resp_domain_SetActive_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in_s_out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_resp_domain_SetInconsistent_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name)
+{
+    return sbus_method_in_s_out__send(mem_ctx, conn, _sbus_sss_key_s_0,
+        busname, object_path, "sssd.Responder.Domain", "SetInconsistent", arg_name);
+}
+
+errno_t
+sbus_call_resp_domain_SetInconsistent_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in_s_out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_resp_negcache_ResetGroups_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, _sbus_sss_key_,
+        busname, object_path, "sssd.Responder.NegativeCache", "ResetGroups");
+}
+
+errno_t
+sbus_call_resp_negcache_ResetGroups_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_resp_negcache_ResetUsers_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, _sbus_sss_key_,
+        busname, object_path, "sssd.Responder.NegativeCache", "ResetUsers");
+}
+
+errno_t
+sbus_call_resp_negcache_ResetUsers_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_dp_dp_getAccountDomain_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     uint32_t arg_entry_type,
+     const char * arg_filter,
+     uint32_t arg_cli_id)
+{
+    return sbus_method_in_uusu_out_qus_send(mem_ctx, conn, _sbus_sss_key_uusu_0_1_2,
+        busname, object_path, "sssd.dataprovider", "getAccountDomain", arg_dp_flags, arg_entry_type, arg_filter, arg_cli_id);
+}
+
+errno_t
+sbus_call_dp_dp_getAccountDomain_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _domain_name)
+{
+    return sbus_method_in_uusu_out_qus_recv(mem_ctx, req, _dp_error, _error, _domain_name);
+}
+
+struct tevent_req *
+sbus_call_dp_dp_getAccountInfo_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     uint32_t arg_entry_type,
+     const char * arg_filter,
+     const char * arg_domain,
+     const char * arg_extra,
+     uint32_t arg_cli_id)
+{
+    return sbus_method_in_uusssu_out_qus_send(mem_ctx, conn, _sbus_sss_key_uusssu_0_1_2_3_4,
+        busname, object_path, "sssd.dataprovider", "getAccountInfo", arg_dp_flags, arg_entry_type, arg_filter, arg_domain, arg_extra, arg_cli_id);
+}
+
+errno_t
+sbus_call_dp_dp_getAccountInfo_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _error_message)
+{
+    return sbus_method_in_uusssu_out_qus_recv(mem_ctx, req, _dp_error, _error, _error_message);
+}
+
+struct tevent_req *
+sbus_call_dp_dp_getDomains_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_domain_hint)
+{
+    return sbus_method_in_s_out_qus_send(mem_ctx, conn, _sbus_sss_key_s_0,
+        busname, object_path, "sssd.dataprovider", "getDomains", arg_domain_hint);
+}
+
+errno_t
+sbus_call_dp_dp_getDomains_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _error_message)
+{
+    return sbus_method_in_s_out_qus_recv(mem_ctx, req, _dp_error, _error, _error_message);
+}
+
+struct tevent_req *
+sbus_call_dp_dp_hostHandler_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     const char * arg_name,
+     const char * arg_alias,
+     uint32_t arg_cli_id)
+{
+    return sbus_method_in_ussu_out_qus_send(mem_ctx, conn, _sbus_sss_key_ussu_0_1,
+        busname, object_path, "sssd.dataprovider", "hostHandler", arg_dp_flags, arg_name, arg_alias, arg_cli_id);
+}
+
+errno_t
+sbus_call_dp_dp_hostHandler_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _error_message)
+{
+    return sbus_method_in_ussu_out_qus_recv(mem_ctx, req, _dp_error, _error, _error_message);
+}
+
+struct tevent_req *
+sbus_call_dp_dp_pamHandler_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     struct pam_data * arg_pam_data)
+{
+    return sbus_method_in_pam_data_out_pam_response_send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.dataprovider", "pamHandler", arg_pam_data);
+}
+
+errno_t
+sbus_call_dp_dp_pamHandler_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     struct pam_data ** _pam_response)
+{
+    return sbus_method_in_pam_data_out_pam_response_recv(mem_ctx, req, _pam_response);
+}
+
+struct tevent_req *
+sbus_call_dp_dp_resolverHandler_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     uint32_t arg_entry_type,
+     uint32_t arg_filter_type,
+     const char * arg_filter_value,
+     uint32_t arg_cli_id)
+{
+    return sbus_method_in_uuusu_out_qus_send(mem_ctx, conn, _sbus_sss_key_uuusu_0_1_2_3,
+        busname, object_path, "sssd.dataprovider", "resolverHandler", arg_dp_flags, arg_entry_type, arg_filter_type, arg_filter_value, arg_cli_id);
+}
+
+errno_t
+sbus_call_dp_dp_resolverHandler_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _error_message)
+{
+    return sbus_method_in_uuusu_out_qus_recv(mem_ctx, req, _dp_error, _error, _error_message);
+}
+
+struct tevent_req *
+sbus_call_dp_dp_sudoHandler_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     DBusMessage *raw_message)
+{
+    return sbus_method_in_raw_out_qus_send(mem_ctx, conn, raw_message);
+}
+
+errno_t
+sbus_call_dp_dp_sudoHandler_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _error_message)
+{
+    return sbus_method_in_raw_out_qus_recv(mem_ctx, req, _dp_error, _error, _error_message);
+}
+
+struct tevent_req *
+sbus_call_monitor_RegisterService_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name,
+     uint16_t arg_version,
+     uint16_t arg_type)
+{
+    return sbus_method_in_sqq_out_q_send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.monitor", "RegisterService", arg_name, arg_version, arg_type);
+}
+
+errno_t
+sbus_call_monitor_RegisterService_recv
+    (struct tevent_req *req,
+     uint16_t* _monitor_version)
+{
+    return sbus_method_in_sqq_out_q_recv(req, _monitor_version);
+}
+
+struct tevent_req *
+sbus_call_nss_memcache_InvalidateAllGroups_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, _sbus_sss_key_,
+        busname, object_path, "sssd.nss.MemoryCache", "InvalidateAllGroups");
+}
+
+errno_t
+sbus_call_nss_memcache_InvalidateAllGroups_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_nss_memcache_InvalidateAllInitgroups_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, _sbus_sss_key_,
+        busname, object_path, "sssd.nss.MemoryCache", "InvalidateAllInitgroups");
+}
+
+errno_t
+sbus_call_nss_memcache_InvalidateAllInitgroups_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_nss_memcache_InvalidateAllUsers_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, _sbus_sss_key_,
+        busname, object_path, "sssd.nss.MemoryCache", "InvalidateAllUsers");
+}
+
+errno_t
+sbus_call_nss_memcache_InvalidateAllUsers_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_nss_memcache_InvalidateGroupById_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_gid)
+{
+    return sbus_method_in_u_out__send(mem_ctx, conn, _sbus_sss_key_u_0,
+        busname, object_path, "sssd.nss.MemoryCache", "InvalidateGroupById", arg_gid);
+}
+
+errno_t
+sbus_call_nss_memcache_InvalidateGroupById_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in_u_out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_nss_memcache_UpdateInitgroups_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_user,
+     const char * arg_domain,
+     uint32_t * arg_groups)
+{
+    return sbus_method_in_ssau_out__send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.nss.MemoryCache", "UpdateInitgroups", arg_user, arg_domain, arg_groups);
+}
+
+errno_t
+sbus_call_nss_memcache_UpdateInitgroups_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in_ssau_out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_service_clearEnumCache_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.service", "clearEnumCache");
+}
+
+errno_t
+sbus_call_service_clearEnumCache_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_service_clearMemcache_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.service", "clearMemcache");
+}
+
+errno_t
+sbus_call_service_clearMemcache_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_service_clearNegcache_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.service", "clearNegcache");
+}
+
+errno_t
+sbus_call_service_clearNegcache_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_service_goOffline_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.service", "goOffline");
+}
+
+errno_t
+sbus_call_service_goOffline_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_service_resetOffline_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.service", "resetOffline");
+}
+
+errno_t
+sbus_call_service_resetOffline_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_service_rotateLogs_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.service", "rotateLogs");
+}
+
+errno_t
+sbus_call_service_rotateLogs_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
+
+struct tevent_req *
+sbus_call_service_sysbusReconnect_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path)
+{
+    return sbus_method_in__out__send(mem_ctx, conn, NULL,
+        busname, object_path, "sssd.service", "sysbusReconnect");
+}
+
+errno_t
+sbus_call_service_sysbusReconnect_recv
+    (struct tevent_req *req)
+{
+    return sbus_method_in__out__recv(req);
+}
diff --git a/src/sss_iface/sbus_sss_client_async.h b/src/sss_iface/sbus_sss_client_async.h
new file mode 100644
index 0000000..10cdaf7
--- /dev/null
+++ b/src/sss_iface/sbus_sss_client_async.h
@@ -0,0 +1,512 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SBUS_SSS_CLIENT_ASYNC_H_
+#define _SBUS_SSS_CLIENT_ASYNC_H_
+
+#include <errno.h>
+#include <talloc.h>
+#include <tevent.h>
+
+#include "sbus/sbus.h"
+#include "sss_iface/sbus_sss_client_properties.h"
+#include "sss_iface/sss_iface_types.h"
+
+struct tevent_req *
+sbus_call_fleet_ProcessSSSDFiles_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_uid,
+     const char * arg_user_dir,
+     uint16_t arg_prio);
+
+errno_t
+sbus_call_fleet_ProcessSSSDFiles_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_dp_access_RefreshRules_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_dp_access_RefreshRules_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_dp_autofs_Enumerate_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     const char * arg_mapname,
+     uint32_t arg_cli_id);
+
+errno_t
+sbus_call_dp_autofs_Enumerate_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_dp_autofs_GetEntry_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     const char * arg_mapname,
+     const char * arg_entryname,
+     uint32_t arg_cli_id);
+
+errno_t
+sbus_call_dp_autofs_GetEntry_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_dp_autofs_GetMap_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     const char * arg_mapname,
+     uint32_t arg_cli_id);
+
+errno_t
+sbus_call_dp_autofs_GetMap_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_dp_backend_IsOnline_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_domain_name);
+
+errno_t
+sbus_call_dp_backend_IsOnline_recv
+    (struct tevent_req *req,
+     bool* _status);
+
+struct tevent_req *
+sbus_call_dp_client_Register_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_Name);
+
+errno_t
+sbus_call_dp_client_Register_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_dp_failover_ActiveServer_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_service_name);
+
+errno_t
+sbus_call_dp_failover_ActiveServer_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     const char ** _server);
+
+struct tevent_req *
+sbus_call_dp_failover_ListServers_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_service_name);
+
+errno_t
+sbus_call_dp_failover_ListServers_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     const char *** _servers);
+
+struct tevent_req *
+sbus_call_dp_failover_ListServices_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_domain_name);
+
+errno_t
+sbus_call_dp_failover_ListServices_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     const char *** _services);
+
+struct tevent_req *
+sbus_call_proxy_auth_PAM_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     struct pam_data * arg_pam_data);
+
+errno_t
+sbus_call_proxy_auth_PAM_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     struct pam_data ** _pam_response);
+
+struct tevent_req *
+sbus_call_proxy_client_Register_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_ID);
+
+errno_t
+sbus_call_proxy_client_Register_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_resp_domain_SetActive_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name);
+
+errno_t
+sbus_call_resp_domain_SetActive_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_resp_domain_SetInconsistent_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name);
+
+errno_t
+sbus_call_resp_domain_SetInconsistent_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_resp_negcache_ResetGroups_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_resp_negcache_ResetGroups_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_resp_negcache_ResetUsers_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_resp_negcache_ResetUsers_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_dp_dp_getAccountDomain_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     uint32_t arg_entry_type,
+     const char * arg_filter,
+     uint32_t arg_cli_id);
+
+errno_t
+sbus_call_dp_dp_getAccountDomain_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _domain_name);
+
+struct tevent_req *
+sbus_call_dp_dp_getAccountInfo_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     uint32_t arg_entry_type,
+     const char * arg_filter,
+     const char * arg_domain,
+     const char * arg_extra,
+     uint32_t arg_cli_id);
+
+errno_t
+sbus_call_dp_dp_getAccountInfo_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _error_message);
+
+struct tevent_req *
+sbus_call_dp_dp_getDomains_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_domain_hint);
+
+errno_t
+sbus_call_dp_dp_getDomains_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _error_message);
+
+struct tevent_req *
+sbus_call_dp_dp_hostHandler_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     const char * arg_name,
+     const char * arg_alias,
+     uint32_t arg_cli_id);
+
+errno_t
+sbus_call_dp_dp_hostHandler_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _error_message);
+
+struct tevent_req *
+sbus_call_dp_dp_pamHandler_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     struct pam_data * arg_pam_data);
+
+errno_t
+sbus_call_dp_dp_pamHandler_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     struct pam_data ** _pam_response);
+
+struct tevent_req *
+sbus_call_dp_dp_resolverHandler_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_dp_flags,
+     uint32_t arg_entry_type,
+     uint32_t arg_filter_type,
+     const char * arg_filter_value,
+     uint32_t arg_cli_id);
+
+errno_t
+sbus_call_dp_dp_resolverHandler_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _error_message);
+
+struct tevent_req *
+sbus_call_dp_dp_sudoHandler_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     DBusMessage *raw_message);
+
+errno_t
+sbus_call_dp_dp_sudoHandler_recv
+    (TALLOC_CTX *mem_ctx,
+     struct tevent_req *req,
+     uint16_t* _dp_error,
+     uint32_t* _error,
+     const char ** _error_message);
+
+struct tevent_req *
+sbus_call_monitor_RegisterService_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name,
+     uint16_t arg_version,
+     uint16_t arg_type);
+
+errno_t
+sbus_call_monitor_RegisterService_recv
+    (struct tevent_req *req,
+     uint16_t* _monitor_version);
+
+struct tevent_req *
+sbus_call_nss_memcache_InvalidateAllGroups_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_nss_memcache_InvalidateAllGroups_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_nss_memcache_InvalidateAllInitgroups_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_nss_memcache_InvalidateAllInitgroups_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_nss_memcache_InvalidateAllUsers_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_nss_memcache_InvalidateAllUsers_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_nss_memcache_InvalidateGroupById_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t arg_gid);
+
+errno_t
+sbus_call_nss_memcache_InvalidateGroupById_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_nss_memcache_UpdateInitgroups_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_user,
+     const char * arg_domain,
+     uint32_t * arg_groups);
+
+errno_t
+sbus_call_nss_memcache_UpdateInitgroups_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_service_clearEnumCache_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_service_clearEnumCache_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_service_clearMemcache_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_service_clearMemcache_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_service_clearNegcache_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_service_clearNegcache_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_service_goOffline_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_service_goOffline_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_service_resetOffline_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_service_resetOffline_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_service_rotateLogs_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_service_rotateLogs_recv
+    (struct tevent_req *req);
+
+struct tevent_req *
+sbus_call_service_sysbusReconnect_send
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_connection *conn,
+     const char *busname,
+     const char *object_path);
+
+errno_t
+sbus_call_service_sysbusReconnect_recv
+    (struct tevent_req *req);
+
+#endif /* _SBUS_SSS_CLIENT_ASYNC_H_ */
diff --git a/src/sss_iface/sbus_sss_client_properties.h b/src/sss_iface/sbus_sss_client_properties.h
new file mode 100644
index 0000000..cfb77b9
--- /dev/null
+++ b/src/sss_iface/sbus_sss_client_properties.h
@@ -0,0 +1,35 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SBUS_SSS_CLIENT_PROPERTIES_H_
+#define _SBUS_SSS_CLIENT_PROPERTIES_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "sss_iface/sss_iface_types.h"
+
+struct sbus_all_service {
+    struct {
+        bool is_set;
+        uint32_t value;
+    } debug_level;
+};
+
+#endif /* _SBUS_SSS_CLIENT_PROPERTIES_H_ */
diff --git a/src/sss_iface/sbus_sss_client_sync.c b/src/sss_iface/sbus_sss_client_sync.c
new file mode 100644
index 0000000..32d6ef8
--- /dev/null
+++ b/src/sss_iface/sbus_sss_client_sync.c
@@ -0,0 +1,303 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 <errno.h>
+#include <talloc.h>
+#include <dbus/dbus.h>
+
+#include "sbus/sbus_sync.h"
+#include "sbus/sbus_sync_private.h"
+#include "sbus/sbus_message.h"
+#include "sbus/interface/sbus_iterator_readers.h"
+#include "sbus/interface_dbus/sbus_dbus_client_sync.h"
+#include "sss_iface/sbus_sss_arguments.h"
+#include "sss_iface/sbus_sss_client_properties.h"
+
+static errno_t
+sbus_method_in_ss_out_o
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_sync_connection *conn,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *method,
+     const char * arg0,
+     const char * arg1,
+     const char ** _arg0)
+{
+    TALLOC_CTX *tmp_ctx;
+    struct _sbus_sss_invoker_args_ss in;
+    struct _sbus_sss_invoker_args_o *out;
+    DBusMessage *reply;
+    errno_t ret;
+
+    tmp_ctx = talloc_new(NULL);
+    if (tmp_ctx == NULL) {
+        DEBUG(SSSDBG_FATAL_FAILURE, "Out of memory!\n");
+        return ENOMEM;
+    }
+
+    out = talloc_zero(tmp_ctx, struct _sbus_sss_invoker_args_o);
+    if (out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    in.arg0 = arg0;
+    in.arg1 = arg1;
+
+    ret = sbus_sync_call_method(tmp_ctx, conn, NULL,
+                                (sbus_invoker_writer_fn)_sbus_sss_invoker_write_ss,
+                                bus, path, iface, method, &in, &reply);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_sss_invoker_read_o, out);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    *_arg0 = talloc_steal(mem_ctx, out->arg0);
+
+    ret = EOK;
+
+done:
+    talloc_free(tmp_ctx);
+
+    return ret;
+}
+
+errno_t
+sbus_call_systemd_RestartUnit
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name,
+     const char * arg_mode,
+     const char ** _arg_job)
+{
+     return sbus_method_in_ss_out_o(mem_ctx, conn,
+          busname, object_path, "org.freedesktop.systemd1.Manager", "RestartUnit", arg_name, arg_mode,
+          _arg_job);
+}
+
+errno_t
+sbus_call_systemd_StartUnit
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name,
+     const char * arg_mode,
+     const char ** _arg_job)
+{
+     return sbus_method_in_ss_out_o(mem_ctx, conn,
+          busname, object_path, "org.freedesktop.systemd1.Manager", "StartUnit", arg_name, arg_mode,
+          _arg_job);
+}
+
+errno_t
+sbus_call_systemd_StopUnit
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name,
+     const char * arg_mode,
+     const char ** _arg_job)
+{
+     return sbus_method_in_ss_out_o(mem_ctx, conn,
+          busname, object_path, "org.freedesktop.systemd1.Manager", "StopUnit", arg_name, arg_mode,
+          _arg_job);
+}
+
+static errno_t
+sbus_get_u
+    (struct sbus_sync_connection *conn,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *property,
+     uint32_t* _value)
+{
+    TALLOC_CTX *tmp_ctx;
+    struct _sbus_sss_invoker_args_u *out;
+    sbus_value_reader_fn reader;
+    sbus_value_reader_talloc_fn reader_talloc;
+    DBusMessage *reply;
+    errno_t ret;
+
+    tmp_ctx = talloc_new(NULL);
+    if (tmp_ctx == NULL) {
+        DEBUG(SSSDBG_FATAL_FAILURE, "Out of memory!\n");
+        return ENOMEM;
+    }
+
+    out = talloc_zero(tmp_ctx, struct _sbus_sss_invoker_args_u);
+    if (out == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for output parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = sbus_call_DBusProperties_Get(tmp_ctx, conn,
+              bus, path, iface, property, &reply);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    reader = (sbus_value_reader_fn)sbus_iterator_read_u;
+    reader_talloc = NULL;
+    ret = sbus_parse_get_message(out, reader, reader_talloc, reply, &out->arg0);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    *_value = out->arg0;
+
+    ret = EOK;
+
+done:
+    talloc_free(tmp_ctx);
+
+    return ret;
+}
+
+static errno_t
+sbus_set_u
+    (struct sbus_sync_connection *conn,
+     const char *bus,
+     const char *path,
+     const char *iface,
+     const char *property,
+     uint32_t value)
+{
+    TALLOC_CTX *tmp_ctx;
+    struct _sbus_sss_invoker_args_u in;
+    DBusMessage *raw_message;
+    errno_t ret;
+
+    tmp_ctx = talloc_new(NULL);
+    if (tmp_ctx == NULL) {
+        DEBUG(SSSDBG_FATAL_FAILURE, "Out of memory!\n");
+        return ENOMEM;
+    }
+
+    in.arg0 = value;
+
+    raw_message = sbus_create_set_call(tmp_ctx,
+                      (sbus_invoker_writer_fn)_sbus_sss_invoker_write_u,
+                      bus, path, iface, property,
+                      "u", &in);
+    if (raw_message == NULL) {
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = sbus_call_DBusProperties_Set(conn, raw_message);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = EOK;
+
+done:
+    talloc_free(tmp_ctx);
+
+    return ret;
+}
+
+errno_t
+sbus_get_service_debug_level
+    (struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t* _value)
+{
+    return sbus_get_u(conn, busname, object_path,
+                "sssd.service", "debug_level", _value);
+}
+
+errno_t
+sbus_set_service_debug_level
+    (struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t value)
+{
+    return sbus_set_u(conn, busname, object_path,
+               "sssd.service", "debug_level", value);
+}
+
+errno_t
+sbus_getall_service
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     struct sbus_all_service **_properties)
+{
+    TALLOC_CTX *tmp_ctx;
+    struct sbus_all_service *properties;
+    DBusMessage *reply;
+    errno_t ret;
+
+    tmp_ctx = talloc_new(NULL);
+    if (tmp_ctx == NULL) {
+        DEBUG(SSSDBG_FATAL_FAILURE, "Out of memory!\n");
+        return ENOMEM;
+    }
+
+    properties = talloc_zero(tmp_ctx, struct sbus_all_service);
+    if (properties == NULL) {
+        ret = ENOMEM;
+        goto done;
+    }
+
+    struct sbus_parse_getall_table table[] = {
+        {"debug_level", (sbus_value_reader_fn)sbus_iterator_read_u, NULL,
+         &properties->debug_level.value, &properties->debug_level.is_set},
+        {NULL, NULL, NULL, NULL, NULL}
+    };
+
+    ret = sbus_call_DBusProperties_GetAll(tmp_ctx, conn,
+              busname, object_path, "sssd.service", &reply);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_parse_getall_message(properties, table, reply);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    *_properties = talloc_steal(mem_ctx, properties);
+
+    ret = EOK;
+
+done:
+    talloc_free(tmp_ctx);
+
+    return ret;
+}
diff --git a/src/sss_iface/sbus_sss_client_sync.h b/src/sss_iface/sbus_sss_client_sync.h
new file mode 100644
index 0000000..c4604d3
--- /dev/null
+++ b/src/sss_iface/sbus_sss_client_sync.h
@@ -0,0 +1,83 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SBUS_SSS_CLIENT_SYNC_H_
+#define _SBUS_SSS_CLIENT_SYNC_H_
+
+#include <errno.h>
+#include <talloc.h>
+#include <tevent.h>
+
+#include "sbus/sbus_sync.h"
+#include "sss_iface/sbus_sss_client_properties.h"
+#include "sss_iface/sss_iface_types.h"
+
+errno_t
+sbus_call_systemd_RestartUnit
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name,
+     const char * arg_mode,
+     const char ** _arg_job);
+
+errno_t
+sbus_call_systemd_StartUnit
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name,
+     const char * arg_mode,
+     const char ** _arg_job);
+
+errno_t
+sbus_call_systemd_StopUnit
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     const char * arg_name,
+     const char * arg_mode,
+     const char ** _arg_job);
+
+errno_t
+sbus_get_service_debug_level
+    (struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t* _value);
+
+errno_t
+sbus_set_service_debug_level
+    (struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     uint32_t value);
+
+errno_t
+sbus_getall_service
+    (TALLOC_CTX *mem_ctx,
+     struct sbus_sync_connection *conn,
+     const char *busname,
+     const char *object_path,
+     struct sbus_all_service **_properties);
+
+#endif /* _SBUS_SSS_CLIENT_SYNC_H_ */
diff --git a/src/sss_iface/sbus_sss_interface.h b/src/sss_iface/sbus_sss_interface.h
new file mode 100644
index 0000000..5b4d1c3
--- /dev/null
+++ b/src/sss_iface/sbus_sss_interface.h
@@ -0,0 +1,1011 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SBUS_SSS_INTERFACE_H_
+#define _SBUS_SSS_INTERFACE_H_
+
+#include "sbus/sbus_interface_declarations.h"
+#include "sss_iface/sbus_sss_invokers.h"
+#include "sss_iface/sbus_sss_symbols.h"
+#include "sss_iface/sbus_sss_keygens.h"
+
+/* Interface: org.freedesktop.FleetCommanderClient */
+#define SBUS_IFACE_org_freedesktop_FleetCommanderClient(methods, signals, properties) ({ \
+    sbus_interface("org.freedesktop.FleetCommanderClient", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: org.freedesktop.FleetCommanderClient.ProcessSSSDFiles */
+#define SBUS_METHOD_SYNC_org_freedesktop_FleetCommanderClient_ProcessSSSDFiles(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t, const char *, uint16_t); \
+    sbus_method_sync("ProcessSSSDFiles", \
+        &_sbus_sss_args_org_freedesktop_FleetCommanderClient_ProcessSSSDFiles, \
+        NULL, \
+        _sbus_sss_invoke_in_usq_out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_org_freedesktop_FleetCommanderClient_ProcessSSSDFiles(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t, const char *, uint16_t); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("ProcessSSSDFiles", \
+        &_sbus_sss_args_org_freedesktop_FleetCommanderClient_ProcessSSSDFiles, \
+        NULL, \
+        _sbus_sss_invoke_in_usq_out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: org.freedesktop.systemd1.Manager */
+#define SBUS_IFACE_org_freedesktop_systemd1_Manager(methods, signals, properties) ({ \
+    sbus_interface("org.freedesktop.systemd1.Manager", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: org.freedesktop.systemd1.Manager.RestartUnit */
+#define SBUS_METHOD_SYNC_org_freedesktop_systemd1_Manager_RestartUnit(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *, const char *, const char **); \
+    sbus_method_sync("RestartUnit", \
+        &_sbus_sss_args_org_freedesktop_systemd1_Manager_RestartUnit, \
+        NULL, \
+        _sbus_sss_invoke_in_ss_out_o_send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_org_freedesktop_systemd1_Manager_RestartUnit(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *, const char *); \
+    SBUS_CHECK_RECV((handler_recv), const char **); \
+    sbus_method_async("RestartUnit", \
+        &_sbus_sss_args_org_freedesktop_systemd1_Manager_RestartUnit, \
+        NULL, \
+        _sbus_sss_invoke_in_ss_out_o_send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: org.freedesktop.systemd1.Manager.StartUnit */
+#define SBUS_METHOD_SYNC_org_freedesktop_systemd1_Manager_StartUnit(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *, const char *, const char **); \
+    sbus_method_sync("StartUnit", \
+        &_sbus_sss_args_org_freedesktop_systemd1_Manager_StartUnit, \
+        NULL, \
+        _sbus_sss_invoke_in_ss_out_o_send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_org_freedesktop_systemd1_Manager_StartUnit(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *, const char *); \
+    SBUS_CHECK_RECV((handler_recv), const char **); \
+    sbus_method_async("StartUnit", \
+        &_sbus_sss_args_org_freedesktop_systemd1_Manager_StartUnit, \
+        NULL, \
+        _sbus_sss_invoke_in_ss_out_o_send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: org.freedesktop.systemd1.Manager.StopUnit */
+#define SBUS_METHOD_SYNC_org_freedesktop_systemd1_Manager_StopUnit(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *, const char *, const char **); \
+    sbus_method_sync("StopUnit", \
+        &_sbus_sss_args_org_freedesktop_systemd1_Manager_StopUnit, \
+        NULL, \
+        _sbus_sss_invoke_in_ss_out_o_send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_org_freedesktop_systemd1_Manager_StopUnit(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *, const char *); \
+    SBUS_CHECK_RECV((handler_recv), const char **); \
+    sbus_method_async("StopUnit", \
+        &_sbus_sss_args_org_freedesktop_systemd1_Manager_StopUnit, \
+        NULL, \
+        _sbus_sss_invoke_in_ss_out_o_send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.DataProvider.AccessControl */
+#define SBUS_IFACE_sssd_DataProvider_AccessControl(methods, signals, properties) ({ \
+    sbus_interface("sssd.DataProvider.AccessControl", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.DataProvider.AccessControl.RefreshRules */
+#define SBUS_METHOD_SYNC_sssd_DataProvider_AccessControl_RefreshRules(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("RefreshRules", \
+        &_sbus_sss_args_sssd_DataProvider_AccessControl_RefreshRules, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_DataProvider_AccessControl_RefreshRules(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("RefreshRules", \
+        &_sbus_sss_args_sssd_DataProvider_AccessControl_RefreshRules, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.DataProvider.Autofs */
+#define SBUS_IFACE_sssd_DataProvider_Autofs(methods, signals, properties) ({ \
+    sbus_interface("sssd.DataProvider.Autofs", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.DataProvider.Autofs.Enumerate */
+#define SBUS_METHOD_SYNC_sssd_DataProvider_Autofs_Enumerate(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t, const char *, uint32_t); \
+    sbus_method_sync("Enumerate", \
+        &_sbus_sss_args_sssd_DataProvider_Autofs_Enumerate, \
+        NULL, \
+        _sbus_sss_invoke_in_usu_out__send, \
+        _sbus_sss_key_usu_0_1, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_DataProvider_Autofs_Enumerate(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t, const char *, uint32_t); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("Enumerate", \
+        &_sbus_sss_args_sssd_DataProvider_Autofs_Enumerate, \
+        NULL, \
+        _sbus_sss_invoke_in_usu_out__send, \
+        _sbus_sss_key_usu_0_1, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.DataProvider.Autofs.GetEntry */
+#define SBUS_METHOD_SYNC_sssd_DataProvider_Autofs_GetEntry(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t, const char *, const char *, uint32_t); \
+    sbus_method_sync("GetEntry", \
+        &_sbus_sss_args_sssd_DataProvider_Autofs_GetEntry, \
+        NULL, \
+        _sbus_sss_invoke_in_ussu_out__send, \
+        _sbus_sss_key_ussu_0_1_2, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_DataProvider_Autofs_GetEntry(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t, const char *, const char *, uint32_t); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("GetEntry", \
+        &_sbus_sss_args_sssd_DataProvider_Autofs_GetEntry, \
+        NULL, \
+        _sbus_sss_invoke_in_ussu_out__send, \
+        _sbus_sss_key_ussu_0_1_2, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.DataProvider.Autofs.GetMap */
+#define SBUS_METHOD_SYNC_sssd_DataProvider_Autofs_GetMap(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t, const char *, uint32_t); \
+    sbus_method_sync("GetMap", \
+        &_sbus_sss_args_sssd_DataProvider_Autofs_GetMap, \
+        NULL, \
+        _sbus_sss_invoke_in_usu_out__send, \
+        _sbus_sss_key_usu_0_1, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_DataProvider_Autofs_GetMap(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t, const char *, uint32_t); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("GetMap", \
+        &_sbus_sss_args_sssd_DataProvider_Autofs_GetMap, \
+        NULL, \
+        _sbus_sss_invoke_in_usu_out__send, \
+        _sbus_sss_key_usu_0_1, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.DataProvider.Backend */
+#define SBUS_IFACE_sssd_DataProvider_Backend(methods, signals, properties) ({ \
+    sbus_interface("sssd.DataProvider.Backend", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.DataProvider.Backend.IsOnline */
+#define SBUS_METHOD_SYNC_sssd_DataProvider_Backend_IsOnline(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *, bool*); \
+    sbus_method_sync("IsOnline", \
+        &_sbus_sss_args_sssd_DataProvider_Backend_IsOnline, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out_b_send, \
+        _sbus_sss_key_s_0, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_DataProvider_Backend_IsOnline(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *); \
+    SBUS_CHECK_RECV((handler_recv), bool*); \
+    sbus_method_async("IsOnline", \
+        &_sbus_sss_args_sssd_DataProvider_Backend_IsOnline, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out_b_send, \
+        _sbus_sss_key_s_0, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.DataProvider.Client */
+#define SBUS_IFACE_sssd_DataProvider_Client(methods, signals, properties) ({ \
+    sbus_interface("sssd.DataProvider.Client", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.DataProvider.Client.Register */
+#define SBUS_METHOD_SYNC_sssd_DataProvider_Client_Register(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *); \
+    sbus_method_sync("Register", \
+        &_sbus_sss_args_sssd_DataProvider_Client_Register, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_DataProvider_Client_Register(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("Register", \
+        &_sbus_sss_args_sssd_DataProvider_Client_Register, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.DataProvider.Failover */
+#define SBUS_IFACE_sssd_DataProvider_Failover(methods, signals, properties) ({ \
+    sbus_interface("sssd.DataProvider.Failover", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.DataProvider.Failover.ActiveServer */
+#define SBUS_METHOD_SYNC_sssd_DataProvider_Failover_ActiveServer(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \
+    sbus_method_sync("ActiveServer", \
+        &_sbus_sss_args_sssd_DataProvider_Failover_ActiveServer, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out_s_send, \
+        _sbus_sss_key_s_0, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_DataProvider_Failover_ActiveServer(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *); \
+    SBUS_CHECK_RECV((handler_recv), const char **); \
+    sbus_method_async("ActiveServer", \
+        &_sbus_sss_args_sssd_DataProvider_Failover_ActiveServer, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out_s_send, \
+        _sbus_sss_key_s_0, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.DataProvider.Failover.ListServers */
+#define SBUS_METHOD_SYNC_sssd_DataProvider_Failover_ListServers(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *, const char ***); \
+    sbus_method_sync("ListServers", \
+        &_sbus_sss_args_sssd_DataProvider_Failover_ListServers, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out_as_send, \
+        _sbus_sss_key_s_0, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_DataProvider_Failover_ListServers(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *); \
+    SBUS_CHECK_RECV((handler_recv), const char ***); \
+    sbus_method_async("ListServers", \
+        &_sbus_sss_args_sssd_DataProvider_Failover_ListServers, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out_as_send, \
+        _sbus_sss_key_s_0, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.DataProvider.Failover.ListServices */
+#define SBUS_METHOD_SYNC_sssd_DataProvider_Failover_ListServices(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *, const char ***); \
+    sbus_method_sync("ListServices", \
+        &_sbus_sss_args_sssd_DataProvider_Failover_ListServices, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out_as_send, \
+        _sbus_sss_key_s_0, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_DataProvider_Failover_ListServices(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *); \
+    SBUS_CHECK_RECV((handler_recv), const char ***); \
+    sbus_method_async("ListServices", \
+        &_sbus_sss_args_sssd_DataProvider_Failover_ListServices, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out_as_send, \
+        _sbus_sss_key_s_0, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.ProxyChild.Auth */
+#define SBUS_IFACE_sssd_ProxyChild_Auth(methods, signals, properties) ({ \
+    sbus_interface("sssd.ProxyChild.Auth", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.ProxyChild.Auth.PAM */
+#define SBUS_METHOD_SYNC_sssd_ProxyChild_Auth_PAM(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), struct pam_data *, struct pam_data **); \
+    sbus_method_sync("PAM", \
+        &_sbus_sss_args_sssd_ProxyChild_Auth_PAM, \
+        NULL, \
+        _sbus_sss_invoke_in_pam_data_out_pam_response_send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_ProxyChild_Auth_PAM(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), struct pam_data *); \
+    SBUS_CHECK_RECV((handler_recv), struct pam_data **); \
+    sbus_method_async("PAM", \
+        &_sbus_sss_args_sssd_ProxyChild_Auth_PAM, \
+        NULL, \
+        _sbus_sss_invoke_in_pam_data_out_pam_response_send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.ProxyChild.Client */
+#define SBUS_IFACE_sssd_ProxyChild_Client(methods, signals, properties) ({ \
+    sbus_interface("sssd.ProxyChild.Client", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.ProxyChild.Client.Register */
+#define SBUS_METHOD_SYNC_sssd_ProxyChild_Client_Register(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t); \
+    sbus_method_sync("Register", \
+        &_sbus_sss_args_sssd_ProxyChild_Client_Register, \
+        NULL, \
+        _sbus_sss_invoke_in_u_out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_ProxyChild_Client_Register(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("Register", \
+        &_sbus_sss_args_sssd_ProxyChild_Client_Register, \
+        NULL, \
+        _sbus_sss_invoke_in_u_out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.Responder.Domain */
+#define SBUS_IFACE_sssd_Responder_Domain(methods, signals, properties) ({ \
+    sbus_interface("sssd.Responder.Domain", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.Responder.Domain.SetActive */
+#define SBUS_METHOD_SYNC_sssd_Responder_Domain_SetActive(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *); \
+    sbus_method_sync("SetActive", \
+        &_sbus_sss_args_sssd_Responder_Domain_SetActive, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out__send, \
+        _sbus_sss_key_s_0, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_Responder_Domain_SetActive(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("SetActive", \
+        &_sbus_sss_args_sssd_Responder_Domain_SetActive, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out__send, \
+        _sbus_sss_key_s_0, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.Responder.Domain.SetInconsistent */
+#define SBUS_METHOD_SYNC_sssd_Responder_Domain_SetInconsistent(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *); \
+    sbus_method_sync("SetInconsistent", \
+        &_sbus_sss_args_sssd_Responder_Domain_SetInconsistent, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out__send, \
+        _sbus_sss_key_s_0, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_Responder_Domain_SetInconsistent(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("SetInconsistent", \
+        &_sbus_sss_args_sssd_Responder_Domain_SetInconsistent, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out__send, \
+        _sbus_sss_key_s_0, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.Responder.NegativeCache */
+#define SBUS_IFACE_sssd_Responder_NegativeCache(methods, signals, properties) ({ \
+    sbus_interface("sssd.Responder.NegativeCache", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.Responder.NegativeCache.ResetGroups */
+#define SBUS_METHOD_SYNC_sssd_Responder_NegativeCache_ResetGroups(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("ResetGroups", \
+        &_sbus_sss_args_sssd_Responder_NegativeCache_ResetGroups, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_Responder_NegativeCache_ResetGroups(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("ResetGroups", \
+        &_sbus_sss_args_sssd_Responder_NegativeCache_ResetGroups, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.Responder.NegativeCache.ResetUsers */
+#define SBUS_METHOD_SYNC_sssd_Responder_NegativeCache_ResetUsers(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("ResetUsers", \
+        &_sbus_sss_args_sssd_Responder_NegativeCache_ResetUsers, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_Responder_NegativeCache_ResetUsers(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("ResetUsers", \
+        &_sbus_sss_args_sssd_Responder_NegativeCache_ResetUsers, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.dataprovider */
+#define SBUS_IFACE_sssd_dataprovider(methods, signals, properties) ({ \
+    sbus_interface("sssd.dataprovider", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.dataprovider.getAccountDomain */
+#define SBUS_METHOD_SYNC_sssd_dataprovider_getAccountDomain(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t, uint32_t, const char *, uint32_t, uint16_t*, uint32_t*, const char **); \
+    sbus_method_sync("getAccountDomain", \
+        &_sbus_sss_args_sssd_dataprovider_getAccountDomain, \
+        NULL, \
+        _sbus_sss_invoke_in_uusu_out_qus_send, \
+        _sbus_sss_key_uusu_0_1_2, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_dataprovider_getAccountDomain(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t, uint32_t, const char *, uint32_t); \
+    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
+    sbus_method_async("getAccountDomain", \
+        &_sbus_sss_args_sssd_dataprovider_getAccountDomain, \
+        NULL, \
+        _sbus_sss_invoke_in_uusu_out_qus_send, \
+        _sbus_sss_key_uusu_0_1_2, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.dataprovider.getAccountInfo */
+#define SBUS_METHOD_SYNC_sssd_dataprovider_getAccountInfo(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t, uint32_t, const char *, const char *, const char *, uint32_t, uint16_t*, uint32_t*, const char **); \
+    sbus_method_sync("getAccountInfo", \
+        &_sbus_sss_args_sssd_dataprovider_getAccountInfo, \
+        NULL, \
+        _sbus_sss_invoke_in_uusssu_out_qus_send, \
+        _sbus_sss_key_uusssu_0_1_2_3_4, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_dataprovider_getAccountInfo(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t, uint32_t, const char *, const char *, const char *, uint32_t); \
+    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
+    sbus_method_async("getAccountInfo", \
+        &_sbus_sss_args_sssd_dataprovider_getAccountInfo, \
+        NULL, \
+        _sbus_sss_invoke_in_uusssu_out_qus_send, \
+        _sbus_sss_key_uusssu_0_1_2_3_4, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.dataprovider.getDomains */
+#define SBUS_METHOD_SYNC_sssd_dataprovider_getDomains(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *, uint16_t*, uint32_t*, const char **); \
+    sbus_method_sync("getDomains", \
+        &_sbus_sss_args_sssd_dataprovider_getDomains, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out_qus_send, \
+        _sbus_sss_key_s_0, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_dataprovider_getDomains(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *); \
+    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
+    sbus_method_async("getDomains", \
+        &_sbus_sss_args_sssd_dataprovider_getDomains, \
+        NULL, \
+        _sbus_sss_invoke_in_s_out_qus_send, \
+        _sbus_sss_key_s_0, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.dataprovider.hostHandler */
+#define SBUS_METHOD_SYNC_sssd_dataprovider_hostHandler(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t, const char *, const char *, uint32_t, uint16_t*, uint32_t*, const char **); \
+    sbus_method_sync("hostHandler", \
+        &_sbus_sss_args_sssd_dataprovider_hostHandler, \
+        NULL, \
+        _sbus_sss_invoke_in_ussu_out_qus_send, \
+        _sbus_sss_key_ussu_0_1, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_dataprovider_hostHandler(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t, const char *, const char *, uint32_t); \
+    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
+    sbus_method_async("hostHandler", \
+        &_sbus_sss_args_sssd_dataprovider_hostHandler, \
+        NULL, \
+        _sbus_sss_invoke_in_ussu_out_qus_send, \
+        _sbus_sss_key_ussu_0_1, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.dataprovider.pamHandler */
+#define SBUS_METHOD_SYNC_sssd_dataprovider_pamHandler(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), struct pam_data *, struct pam_data **); \
+    sbus_method_sync("pamHandler", \
+        &_sbus_sss_args_sssd_dataprovider_pamHandler, \
+        NULL, \
+        _sbus_sss_invoke_in_pam_data_out_pam_response_send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_dataprovider_pamHandler(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), struct pam_data *); \
+    SBUS_CHECK_RECV((handler_recv), struct pam_data **); \
+    sbus_method_async("pamHandler", \
+        &_sbus_sss_args_sssd_dataprovider_pamHandler, \
+        NULL, \
+        _sbus_sss_invoke_in_pam_data_out_pam_response_send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.dataprovider.resolverHandler */
+#define SBUS_METHOD_SYNC_sssd_dataprovider_resolverHandler(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t, uint32_t, uint32_t, const char *, uint32_t, uint16_t*, uint32_t*, const char **); \
+    sbus_method_sync("resolverHandler", \
+        &_sbus_sss_args_sssd_dataprovider_resolverHandler, \
+        NULL, \
+        _sbus_sss_invoke_in_uuusu_out_qus_send, \
+        _sbus_sss_key_uuusu_0_1_2_3, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_dataprovider_resolverHandler(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t, uint32_t, uint32_t, const char *, uint32_t); \
+    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
+    sbus_method_async("resolverHandler", \
+        &_sbus_sss_args_sssd_dataprovider_resolverHandler, \
+        NULL, \
+        _sbus_sss_invoke_in_uuusu_out_qus_send, \
+        _sbus_sss_key_uuusu_0_1_2_3, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.dataprovider.sudoHandler */
+#define SBUS_METHOD_SYNC_sssd_dataprovider_sudoHandler(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), DBusMessageIter *, uint16_t*, uint32_t*, const char **); \
+    sbus_method_sync("sudoHandler", \
+        &_sbus_sss_args_sssd_dataprovider_sudoHandler, \
+        NULL, \
+        _sbus_sss_invoke_in_raw_out_qus_send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_dataprovider_sudoHandler(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), DBusMessageIter *); \
+    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
+    sbus_method_async("sudoHandler", \
+        &_sbus_sss_args_sssd_dataprovider_sudoHandler, \
+        NULL, \
+        _sbus_sss_invoke_in_raw_out_qus_send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.monitor */
+#define SBUS_IFACE_sssd_monitor(methods, signals, properties) ({ \
+    sbus_interface("sssd.monitor", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.monitor.RegisterService */
+#define SBUS_METHOD_SYNC_sssd_monitor_RegisterService(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *, uint16_t, uint16_t, uint16_t*); \
+    sbus_method_sync("RegisterService", \
+        &_sbus_sss_args_sssd_monitor_RegisterService, \
+        NULL, \
+        _sbus_sss_invoke_in_sqq_out_q_send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_monitor_RegisterService(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *, uint16_t, uint16_t); \
+    SBUS_CHECK_RECV((handler_recv), uint16_t*); \
+    sbus_method_async("RegisterService", \
+        &_sbus_sss_args_sssd_monitor_RegisterService, \
+        NULL, \
+        _sbus_sss_invoke_in_sqq_out_q_send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.nss.MemoryCache */
+#define SBUS_IFACE_sssd_nss_MemoryCache(methods, signals, properties) ({ \
+    sbus_interface("sssd.nss.MemoryCache", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.nss.MemoryCache.InvalidateAllGroups */
+#define SBUS_METHOD_SYNC_sssd_nss_MemoryCache_InvalidateAllGroups(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("InvalidateAllGroups", \
+        &_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllGroups, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_nss_MemoryCache_InvalidateAllGroups(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("InvalidateAllGroups", \
+        &_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllGroups, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.nss.MemoryCache.InvalidateAllInitgroups */
+#define SBUS_METHOD_SYNC_sssd_nss_MemoryCache_InvalidateAllInitgroups(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("InvalidateAllInitgroups", \
+        &_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllInitgroups, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_nss_MemoryCache_InvalidateAllInitgroups(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("InvalidateAllInitgroups", \
+        &_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllInitgroups, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.nss.MemoryCache.InvalidateAllUsers */
+#define SBUS_METHOD_SYNC_sssd_nss_MemoryCache_InvalidateAllUsers(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("InvalidateAllUsers", \
+        &_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllUsers, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_nss_MemoryCache_InvalidateAllUsers(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("InvalidateAllUsers", \
+        &_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllUsers, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        _sbus_sss_key_, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.nss.MemoryCache.InvalidateGroupById */
+#define SBUS_METHOD_SYNC_sssd_nss_MemoryCache_InvalidateGroupById(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t); \
+    sbus_method_sync("InvalidateGroupById", \
+        &_sbus_sss_args_sssd_nss_MemoryCache_InvalidateGroupById, \
+        NULL, \
+        _sbus_sss_invoke_in_u_out__send, \
+        _sbus_sss_key_u_0, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_nss_MemoryCache_InvalidateGroupById(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("InvalidateGroupById", \
+        &_sbus_sss_args_sssd_nss_MemoryCache_InvalidateGroupById, \
+        NULL, \
+        _sbus_sss_invoke_in_u_out__send, \
+        _sbus_sss_key_u_0, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.nss.MemoryCache.UpdateInitgroups */
+#define SBUS_METHOD_SYNC_sssd_nss_MemoryCache_UpdateInitgroups(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), const char *, const char *, uint32_t *); \
+    sbus_method_sync("UpdateInitgroups", \
+        &_sbus_sss_args_sssd_nss_MemoryCache_UpdateInitgroups, \
+        NULL, \
+        _sbus_sss_invoke_in_ssau_out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_nss_MemoryCache_UpdateInitgroups(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), const char *, const char *, uint32_t *); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("UpdateInitgroups", \
+        &_sbus_sss_args_sssd_nss_MemoryCache_UpdateInitgroups, \
+        NULL, \
+        _sbus_sss_invoke_in_ssau_out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Interface: sssd.service */
+#define SBUS_IFACE_sssd_service(methods, signals, properties) ({ \
+    sbus_interface("sssd.service", NULL, \
+        (methods), (signals), (properties)); \
+})
+
+/* Method: sssd.service.clearEnumCache */
+#define SBUS_METHOD_SYNC_sssd_service_clearEnumCache(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("clearEnumCache", \
+        &_sbus_sss_args_sssd_service_clearEnumCache, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_service_clearEnumCache(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("clearEnumCache", \
+        &_sbus_sss_args_sssd_service_clearEnumCache, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.service.clearMemcache */
+#define SBUS_METHOD_SYNC_sssd_service_clearMemcache(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("clearMemcache", \
+        &_sbus_sss_args_sssd_service_clearMemcache, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_service_clearMemcache(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("clearMemcache", \
+        &_sbus_sss_args_sssd_service_clearMemcache, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.service.clearNegcache */
+#define SBUS_METHOD_SYNC_sssd_service_clearNegcache(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("clearNegcache", \
+        &_sbus_sss_args_sssd_service_clearNegcache, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_service_clearNegcache(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("clearNegcache", \
+        &_sbus_sss_args_sssd_service_clearNegcache, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.service.goOffline */
+#define SBUS_METHOD_SYNC_sssd_service_goOffline(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("goOffline", \
+        &_sbus_sss_args_sssd_service_goOffline, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_service_goOffline(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("goOffline", \
+        &_sbus_sss_args_sssd_service_goOffline, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.service.resetOffline */
+#define SBUS_METHOD_SYNC_sssd_service_resetOffline(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("resetOffline", \
+        &_sbus_sss_args_sssd_service_resetOffline, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_service_resetOffline(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("resetOffline", \
+        &_sbus_sss_args_sssd_service_resetOffline, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.service.rotateLogs */
+#define SBUS_METHOD_SYNC_sssd_service_rotateLogs(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("rotateLogs", \
+        &_sbus_sss_args_sssd_service_rotateLogs, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_service_rotateLogs(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("rotateLogs", \
+        &_sbus_sss_args_sssd_service_rotateLogs, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Method: sssd.service.sysbusReconnect */
+#define SBUS_METHOD_SYNC_sssd_service_sysbusReconnect(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data)); \
+    sbus_method_sync("sysbusReconnect", \
+        &_sbus_sss_args_sssd_service_sysbusReconnect, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler), (data)); \
+})
+
+#define SBUS_METHOD_ASYNC_sssd_service_sysbusReconnect(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_method_async("sysbusReconnect", \
+        &_sbus_sss_args_sssd_service_sysbusReconnect, \
+        NULL, \
+        _sbus_sss_invoke_in__out__send, \
+        NULL, \
+        (handler_send), (handler_recv), (data)); \
+})
+
+/* Property: sssd.service.debug_level */
+#define SBUS_GETTER_SYNC_sssd_service_debug_level(handler, data) ({ \
+    SBUS_CHECK_SYNC((handler), (data), uint32_t*); \
+    sbus_property_sync("debug_level", "u", SBUS_PROPERTY_READABLE, \
+       NULL, \
+       _sbus_sss_invoke_in__out_u_send, \
+       (handler), (data)); \
+})
+
+#define SBUS_GETTER_ASYNC_sssd_service_debug_level(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data)); \
+    SBUS_CHECK_RECV((handler_recv), uint32_t*); \
+    sbus_property_async("debug_level", "u", SBUS_PROPERTY_READABLE, \
+       NULL, \
+       _sbus_sss_invoke_in__out_u_send, \
+       (handler_send), (handler_recv), (data)); \
+})
+
+#define SBUS_SETTER_SYNC_sssd_service_debug_level(handler, data) ({\
+    SBUS_CHECK_SYNC((handler), (data), uint32_t); \
+    sbus_property_sync("debug_level", "u", SBUS_PROPERTY_WRITABLE, \
+       NULL, \
+       _sbus_sss_invoke_in_u_out__send, \
+       (handler), (data)); \
+})
+
+#define SBUS_SETTER_ASYNC_sssd_service_debug_level(handler_send, handler_recv, data) ({ \
+    SBUS_CHECK_SEND((handler_send), (data), uint32_t); \
+    SBUS_CHECK_RECV((handler_recv)); \
+    sbus_property_async("debug_level", "u", SBUS_PROPERTY_WRITABLE, \
+       NULL, \
+       _sbus_sss_invoke_in_u_out__send, \
+       (handler_send), (handler_recv), (data)); \
+})
+
+#endif /* _SBUS_SSS_INTERFACE_H_ */
diff --git a/src/sss_iface/sbus_sss_invokers.c b/src/sss_iface/sbus_sss_invokers.c
new file mode 100644
index 0000000..ef03524
--- /dev/null
+++ b/src/sss_iface/sbus_sss_invokers.c
@@ -0,0 +1,3577 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 <errno.h>
+#include <talloc.h>
+#include <tevent.h>
+#include <dbus/dbus.h>
+
+#include "sbus/sbus_private.h"
+#include "sbus/sbus_interface_declarations.h"
+#include "sss_iface/sbus_sss_arguments.h"
+#include "sss_iface/sbus_sss_invokers.h"
+
+static errno_t
+sbus_invoker_schedule(TALLOC_CTX *mem_ctx,
+                      struct tevent_context *ev,
+                      void *handler,
+                      void *private_data)
+{
+    /* Schedule invoker as a timed event so it is processed after other
+     * event types. This will give dispatcher a chance to catch more
+     * messages before this invoker is triggered and therefore it will
+     * allow to potentially chain more request into one, especially for
+     * synchronous handlers. */
+
+    struct tevent_timer *te;
+    struct timeval tv;
+
+    tv = tevent_timeval_current_ofs(0, 5);
+    te = tevent_add_timer(ev, mem_ctx, tv, handler, private_data);
+    if (te == NULL) {
+        /* There is not enough memory to create a timer. We can't do
+         * anything about it. */
+        DEBUG(SSSDBG_OP_FAILURE, "Could not add invoker event!\n");
+        return ENOMEM;
+    }
+
+    return EOK;
+}
+
+struct _sbus_sss_invoke_in__out__state {
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in__out__step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in__out__done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in__out__send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in__out__state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in__out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in__out__step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, NULL, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in__out__step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in__out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in__out__state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in__out__done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in__out__done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in__out__state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in__out__state);
+
+    ret = state->handler.recv(state, subreq);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in__out_u_state {
+    struct _sbus_sss_invoker_args_u out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, uint32_t*);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, uint32_t*);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in__out_u_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in__out_u_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in__out_u_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in__out_u_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in__out_u_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in__out_u_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, NULL, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in__out_u_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in__out_u_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in__out_u_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, &state->out.arg0);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_u(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in__out_u_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in__out_u_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in__out_u_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in__out_u_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_u(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_pam_data_out_pam_response_state {
+    struct _sbus_sss_invoker_args_pam_data *in;
+    struct _sbus_sss_invoker_args_pam_response out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, struct pam_data *, struct pam_data **);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, struct pam_data *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, struct pam_data **);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_pam_data_out_pam_response_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_pam_data_out_pam_response_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_pam_data_out_pam_response_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_pam_data_out_pam_response_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_pam_data_out_pam_response_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_pam_data);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_pam_data(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_pam_data_out_pam_response_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_pam_data_out_pam_response_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_pam_data_out_pam_response_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_pam_data_out_pam_response_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, &state->out.arg0);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_pam_response(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_pam_data_out_pam_response_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_pam_data_out_pam_response_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_pam_data_out_pam_response_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_pam_data_out_pam_response_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_pam_response(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_raw_out_qus_state {
+    struct _sbus_sss_invoker_args_qus out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, DBusMessageIter *, uint16_t*, uint32_t*, const char **);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, DBusMessageIter *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, uint16_t*, uint32_t*, const char **);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_raw_out_qus_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_raw_out_qus_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_raw_out_qus_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_raw_out_qus_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_raw_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_raw_out_qus_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, NULL, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_raw_out_qus_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_raw_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_raw_out_qus_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->read_iterator, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->read_iterator);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_raw_out_qus_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_raw_out_qus_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_raw_out_qus_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_raw_out_qus_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_s_out__state {
+    struct _sbus_sss_invoker_args_s *in;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, const char *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_s_out__step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_s_out__done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_s_out__send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_s_out__state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_s_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_s);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_s(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_s_out__step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_s_out__step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_s_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_s_out__state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_s_out__done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_s_out__done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_s_out__state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_s_out__state);
+
+    ret = state->handler.recv(state, subreq);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_s_out_as_state {
+    struct _sbus_sss_invoker_args_s *in;
+    struct _sbus_sss_invoker_args_as out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *, const char ***);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, const char *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, const char ***);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_s_out_as_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_s_out_as_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_s_out_as_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_s_out_as_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_s_out_as_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_s);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_s(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_s_out_as_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_s_out_as_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_s_out_as_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_s_out_as_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, &state->out.arg0);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_as(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_s_out_as_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_s_out_as_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_s_out_as_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_s_out_as_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_as(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_s_out_b_state {
+    struct _sbus_sss_invoker_args_s *in;
+    struct _sbus_sss_invoker_args_b out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *, bool*);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, const char *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, bool*);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_s_out_b_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_s_out_b_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_s_out_b_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_s_out_b_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_s_out_b_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_s);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_s(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_s_out_b_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_s_out_b_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_s_out_b_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_s_out_b_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, &state->out.arg0);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_b(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_s_out_b_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_s_out_b_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_s_out_b_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_s_out_b_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_b(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_s_out_qus_state {
+    struct _sbus_sss_invoker_args_s *in;
+    struct _sbus_sss_invoker_args_qus out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *, uint16_t*, uint32_t*, const char **);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, const char *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, uint16_t*, uint32_t*, const char **);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_s_out_qus_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_s_out_qus_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_s_out_qus_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_s_out_qus_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_s_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_s);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_s(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_s_out_qus_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_s_out_qus_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_s_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_s_out_qus_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_s_out_qus_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_s_out_qus_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_s_out_qus_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_s_out_qus_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_s_out_s_state {
+    struct _sbus_sss_invoker_args_s *in;
+    struct _sbus_sss_invoker_args_s out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *, const char **);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, const char *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, const char **);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_s_out_s_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_s_out_s_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_s_out_s_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_s_out_s_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_s_out_s_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_s);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_s(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_s_out_s_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_s_out_s_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_s_out_s_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_s_out_s_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, &state->out.arg0);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_s(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_s_out_s_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_s_out_s_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_s_out_s_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_s_out_s_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_s(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_sqq_out_q_state {
+    struct _sbus_sss_invoker_args_sqq *in;
+    struct _sbus_sss_invoker_args_q out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *, uint16_t, uint16_t, uint16_t*);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, const char *, uint16_t, uint16_t);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, uint16_t*);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_sqq_out_q_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_sqq_out_q_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_sqq_out_q_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_sqq_out_q_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_sqq_out_q_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_sqq);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_sqq(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_sqq_out_q_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_sqq_out_q_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_sqq_out_q_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_sqq_out_q_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, &state->out.arg0);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_q(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_sqq_out_q_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_sqq_out_q_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_sqq_out_q_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_sqq_out_q_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_q(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_ss_out_o_state {
+    struct _sbus_sss_invoker_args_ss *in;
+    struct _sbus_sss_invoker_args_o out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *, const char *, const char **);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, const char *, const char *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, const char **);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_ss_out_o_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_ss_out_o_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_ss_out_o_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_ss_out_o_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_ss_out_o_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_ss);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_ss(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_ss_out_o_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_ss_out_o_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_ss_out_o_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_ss_out_o_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, &state->out.arg0);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_o(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_ss_out_o_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_ss_out_o_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_ss_out_o_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_ss_out_o_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_o(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_ssau_out__state {
+    struct _sbus_sss_invoker_args_ssau *in;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *, const char *, uint32_t *);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, const char *, const char *, uint32_t *);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_ssau_out__step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_ssau_out__done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_ssau_out__send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_ssau_out__state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_ssau_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_ssau);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_ssau(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_ssau_out__step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_ssau_out__step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_ssau_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_ssau_out__state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_ssau_out__done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_ssau_out__done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_ssau_out__state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_ssau_out__state);
+
+    ret = state->handler.recv(state, subreq);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_u_out__state {
+    struct _sbus_sss_invoker_args_u *in;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, uint32_t);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, uint32_t);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_u_out__step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_u_out__done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_u_out__send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_u_out__state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_u_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_u);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_u(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_u_out__step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_u_out__step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_u_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_u_out__state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_u_out__done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_u_out__done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_u_out__state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_u_out__state);
+
+    ret = state->handler.recv(state, subreq);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_usq_out__state {
+    struct _sbus_sss_invoker_args_usq *in;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, uint32_t, const char *, uint16_t);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, uint32_t, const char *, uint16_t);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_usq_out__step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_usq_out__done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_usq_out__send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_usq_out__state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_usq_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_usq);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_usq(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_usq_out__step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_usq_out__step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_usq_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_usq_out__state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_usq_out__done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_usq_out__done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_usq_out__state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_usq_out__state);
+
+    ret = state->handler.recv(state, subreq);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_ussu_out__state {
+    struct _sbus_sss_invoker_args_ussu *in;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, uint32_t, const char *, const char *, uint32_t);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, uint32_t, const char *, const char *, uint32_t);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_ussu_out__step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_ussu_out__done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_ussu_out__send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_ussu_out__state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_ussu_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_ussu);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_ussu(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_ussu_out__step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_ussu_out__step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_ussu_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_ussu_out__state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, state->in->arg3);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, state->in->arg3);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_ussu_out__done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_ussu_out__done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_ussu_out__state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_ussu_out__state);
+
+    ret = state->handler.recv(state, subreq);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_ussu_out_qus_state {
+    struct _sbus_sss_invoker_args_ussu *in;
+    struct _sbus_sss_invoker_args_qus out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, uint32_t, const char *, const char *, uint32_t, uint16_t*, uint32_t*, const char **);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, uint32_t, const char *, const char *, uint32_t);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, uint16_t*, uint32_t*, const char **);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_ussu_out_qus_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_ussu_out_qus_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_ussu_out_qus_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_ussu_out_qus_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_ussu_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_ussu);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_ussu(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_ussu_out_qus_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_ussu_out_qus_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_ussu_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_ussu_out_qus_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, state->in->arg3, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, state->in->arg3);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_ussu_out_qus_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_ussu_out_qus_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_ussu_out_qus_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_ussu_out_qus_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_usu_out__state {
+    struct _sbus_sss_invoker_args_usu *in;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, uint32_t, const char *, uint32_t);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, uint32_t, const char *, uint32_t);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_usu_out__step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_usu_out__done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_usu_out__send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_usu_out__state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_usu_out__state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_usu);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_usu(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_usu_out__step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_usu_out__step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_usu_out__state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_usu_out__state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_usu_out__done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_usu_out__done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_usu_out__state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_usu_out__state);
+
+    ret = state->handler.recv(state, subreq);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_uusssu_out_qus_state {
+    struct _sbus_sss_invoker_args_uusssu *in;
+    struct _sbus_sss_invoker_args_qus out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, uint32_t, uint32_t, const char *, const char *, const char *, uint32_t, uint16_t*, uint32_t*, const char **);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, uint32_t, uint32_t, const char *, const char *, const char *, uint32_t);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, uint16_t*, uint32_t*, const char **);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_uusssu_out_qus_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_uusssu_out_qus_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_uusssu_out_qus_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_uusssu_out_qus_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_uusssu_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_uusssu);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_uusssu(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_uusssu_out_qus_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_uusssu_out_qus_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_uusssu_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_uusssu_out_qus_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, state->in->arg3, state->in->arg4, state->in->arg5, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, state->in->arg3, state->in->arg4, state->in->arg5);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_uusssu_out_qus_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_uusssu_out_qus_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_uusssu_out_qus_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_uusssu_out_qus_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_uusu_out_qus_state {
+    struct _sbus_sss_invoker_args_uusu *in;
+    struct _sbus_sss_invoker_args_qus out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, uint32_t, uint32_t, const char *, uint32_t, uint16_t*, uint32_t*, const char **);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, uint32_t, uint32_t, const char *, uint32_t);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, uint16_t*, uint32_t*, const char **);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_uusu_out_qus_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_uusu_out_qus_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_uusu_out_qus_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_uusu_out_qus_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_uusu_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_uusu);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_uusu(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_uusu_out_qus_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_uusu_out_qus_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_uusu_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_uusu_out_qus_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, state->in->arg3, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, state->in->arg3);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_uusu_out_qus_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_uusu_out_qus_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_uusu_out_qus_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_uusu_out_qus_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
+
+struct _sbus_sss_invoke_in_uuusu_out_qus_state {
+    struct _sbus_sss_invoker_args_uuusu *in;
+    struct _sbus_sss_invoker_args_qus out;
+    struct {
+        enum sbus_handler_type type;
+        void *data;
+        errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, uint32_t, uint32_t, uint32_t, const char *, uint32_t, uint16_t*, uint32_t*, const char **);
+        struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, uint32_t, uint32_t, uint32_t, const char *, uint32_t);
+        errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, uint16_t*, uint32_t*, const char **);
+    } handler;
+
+    struct sbus_request *sbus_req;
+    DBusMessageIter *read_iterator;
+    DBusMessageIter *write_iterator;
+};
+
+static void
+_sbus_sss_invoke_in_uuusu_out_qus_step
+    (struct tevent_context *ev,
+     struct tevent_timer *te,
+     struct timeval tv,
+     void *private_data);
+
+static void
+_sbus_sss_invoke_in_uuusu_out_qus_done
+   (struct tevent_req *subreq);
+
+struct tevent_req *
+_sbus_sss_invoke_in_uuusu_out_qus_send
+   (TALLOC_CTX *mem_ctx,
+    struct tevent_context *ev,
+    struct sbus_request *sbus_req,
+    sbus_invoker_keygen keygen,
+    const struct sbus_handler *handler,
+    DBusMessageIter *read_iterator,
+    DBusMessageIter *write_iterator,
+    const char **_key)
+{
+    struct _sbus_sss_invoke_in_uuusu_out_qus_state *state;
+    struct tevent_req *req;
+    const char *key;
+    errno_t ret;
+
+    req = tevent_req_create(mem_ctx, &state, struct _sbus_sss_invoke_in_uuusu_out_qus_state);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        return NULL;
+    }
+
+    state->handler.type = handler->type;
+    state->handler.data = handler->data;
+    state->handler.sync = handler->sync;
+    state->handler.send = handler->async_send;
+    state->handler.recv = handler->async_recv;
+
+    state->sbus_req = sbus_req;
+    state->read_iterator = read_iterator;
+    state->write_iterator = write_iterator;
+
+    state->in = talloc_zero(state, struct _sbus_sss_invoker_args_uuusu);
+    if (state->in == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unable to allocate space for input parameters!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = _sbus_sss_invoker_read_uuusu(state, read_iterator, state->in);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_invoker_schedule(state, ev, _sbus_sss_invoke_in_uuusu_out_qus_step, req);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_request_key(state, keygen, sbus_req, state->in, &key);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    if (_key != NULL) {
+        *_key = talloc_steal(mem_ctx, key);
+    }
+
+    ret = EAGAIN;
+
+done:
+    if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+        tevent_req_post(req, ev);
+    }
+
+    return req;
+}
+
+static void _sbus_sss_invoke_in_uuusu_out_qus_step
+   (struct tevent_context *ev,
+    struct tevent_timer *te,
+    struct timeval tv,
+    void *private_data)
+{
+    struct _sbus_sss_invoke_in_uuusu_out_qus_state *state;
+    struct tevent_req *subreq;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = talloc_get_type(private_data, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_uuusu_out_qus_state);
+
+    switch (state->handler.type) {
+    case SBUS_HANDLER_SYNC:
+        if (state->handler.sync == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: sync handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        ret = state->handler.sync(state, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, state->in->arg3, state->in->arg4, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+        goto done;
+    case SBUS_HANDLER_ASYNC:
+        if (state->handler.send == NULL || state->handler.recv == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Bug: async handler is not specified!\n");
+            ret = ERR_INTERNAL;
+            goto done;
+        }
+
+        subreq = state->handler.send(state, ev, state->sbus_req, state->handler.data, state->in->arg0, state->in->arg1, state->in->arg2, state->in->arg3, state->in->arg4);
+        if (subreq == NULL) {
+            DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n");
+            ret = ENOMEM;
+            goto done;
+        }
+
+        tevent_req_set_callback(subreq, _sbus_sss_invoke_in_uuusu_out_qus_done, req);
+        ret = EAGAIN;
+        goto done;
+    }
+
+    ret = ERR_INTERNAL;
+
+done:
+    if (ret == EOK) {
+        tevent_req_done(req);
+    } else if (ret != EAGAIN) {
+        tevent_req_error(req, ret);
+    }
+}
+
+static void _sbus_sss_invoke_in_uuusu_out_qus_done(struct tevent_req *subreq)
+{
+    struct _sbus_sss_invoke_in_uuusu_out_qus_state *state;
+    struct tevent_req *req;
+    errno_t ret;
+
+    req = tevent_req_callback_data(subreq, struct tevent_req);
+    state = tevent_req_data(req, struct _sbus_sss_invoke_in_uuusu_out_qus_state);
+
+    ret = state->handler.recv(state, subreq, &state->out.arg0, &state->out.arg1, &state->out.arg2);
+    talloc_zfree(subreq);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    ret = _sbus_sss_invoker_write_qus(state->write_iterator, &state->out);
+    if (ret != EOK) {
+        tevent_req_error(req, ret);
+        return;
+    }
+
+    tevent_req_done(req);
+    return;
+}
diff --git a/src/sss_iface/sbus_sss_invokers.h b/src/sss_iface/sbus_sss_invokers.h
new file mode 100644
index 0000000..823ee99
--- /dev/null
+++ b/src/sss_iface/sbus_sss_invokers.h
@@ -0,0 +1,63 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SBUS_SSS_INVOKERS_H_
+#define _SBUS_SSS_INVOKERS_H_
+
+#include <talloc.h>
+#include <tevent.h>
+#include <dbus/dbus.h>
+
+#include "sbus/sbus_interface_declarations.h"
+#include "sbus/sbus_request.h"
+
+#define _sbus_sss_declare_invoker(input, output)                               \
+    struct tevent_req *                                                   \
+    _sbus_sss_invoke_in_ ## input ## _out_ ## output ## _send                 \
+        (TALLOC_CTX *mem_ctx,                                             \
+         struct tevent_context *ev,                                       \
+         struct sbus_request *sbus_req,                                   \
+         sbus_invoker_keygen keygen,                                      \
+         const struct sbus_handler *handler,                              \
+         DBusMessageIter *read_iterator,                                  \
+         DBusMessageIter *write_iterator,                                 \
+         const char **_key)
+
+_sbus_sss_declare_invoker(, );
+_sbus_sss_declare_invoker(, u);
+_sbus_sss_declare_invoker(pam_data, pam_response);
+_sbus_sss_declare_invoker(raw, qus);
+_sbus_sss_declare_invoker(s, );
+_sbus_sss_declare_invoker(s, as);
+_sbus_sss_declare_invoker(s, b);
+_sbus_sss_declare_invoker(s, qus);
+_sbus_sss_declare_invoker(s, s);
+_sbus_sss_declare_invoker(sqq, q);
+_sbus_sss_declare_invoker(ss, o);
+_sbus_sss_declare_invoker(ssau, );
+_sbus_sss_declare_invoker(u, );
+_sbus_sss_declare_invoker(usq, );
+_sbus_sss_declare_invoker(ussu, );
+_sbus_sss_declare_invoker(ussu, qus);
+_sbus_sss_declare_invoker(usu, );
+_sbus_sss_declare_invoker(uusssu, qus);
+_sbus_sss_declare_invoker(uusu, qus);
+_sbus_sss_declare_invoker(uuusu, qus);
+
+#endif /* _SBUS_SSS_INVOKERS_H_ */
diff --git a/src/sss_iface/sbus_sss_keygens.c b/src/sss_iface/sbus_sss_keygens.c
new file mode 100644
index 0000000..0bded60
--- /dev/null
+++ b/src/sss_iface/sbus_sss_keygens.c
@@ -0,0 +1,175 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 <inttypes.h>
+#include <talloc.h>
+
+#include "sbus/sbus_request.h"
+#include "sss_iface/sbus_sss_arguments.h"
+#include "sss_iface/sbus_sss_keygens.h"
+
+const char *
+_sbus_sss_key_
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req)
+{
+    if (sbus_req->sender == NULL) {
+        return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s",
+            sbus_req->type, sbus_req->interface, sbus_req->member, sbus_req->path);
+    }
+
+    return talloc_asprintf(mem_ctx, "%"PRIi64":%u:%s.%s:%s",
+        sbus_req->sender->uid, sbus_req->type, sbus_req->interface, sbus_req->member, sbus_req->path);
+}
+
+const char *
+_sbus_sss_key_s_0
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_s *args)
+{
+    if (sbus_req->sender == NULL) {
+        return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s:%s",
+            sbus_req->type, sbus_req->interface, sbus_req->member,
+            sbus_req->path, args->arg0);
+    }
+
+    return talloc_asprintf(mem_ctx, "%"PRIi64":%u:%s.%s:%s:%s",
+        sbus_req->sender->uid, sbus_req->type, sbus_req->interface, sbus_req->member,
+        sbus_req->path, args->arg0);
+}
+
+const char *
+_sbus_sss_key_u_0
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_u *args)
+{
+    if (sbus_req->sender == NULL) {
+        return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s:%" PRIu32 "",
+            sbus_req->type, sbus_req->interface, sbus_req->member,
+            sbus_req->path, args->arg0);
+    }
+
+    return talloc_asprintf(mem_ctx, "%"PRIi64":%u:%s.%s:%s:%" PRIu32 "",
+        sbus_req->sender->uid, sbus_req->type, sbus_req->interface, sbus_req->member,
+        sbus_req->path, args->arg0);
+}
+
+const char *
+_sbus_sss_key_ussu_0_1
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_ussu *args)
+{
+    if (sbus_req->sender == NULL) {
+        return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s:%" PRIu32 ":%s",
+            sbus_req->type, sbus_req->interface, sbus_req->member,
+            sbus_req->path, args->arg0, args->arg1);
+    }
+
+    return talloc_asprintf(mem_ctx, "%"PRIi64":%u:%s.%s:%s:%" PRIu32 ":%s",
+        sbus_req->sender->uid, sbus_req->type, sbus_req->interface, sbus_req->member,
+        sbus_req->path, args->arg0, args->arg1);
+}
+
+const char *
+_sbus_sss_key_ussu_0_1_2
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_ussu *args)
+{
+    if (sbus_req->sender == NULL) {
+        return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s:%" PRIu32 ":%s:%s",
+            sbus_req->type, sbus_req->interface, sbus_req->member,
+            sbus_req->path, args->arg0, args->arg1, args->arg2);
+    }
+
+    return talloc_asprintf(mem_ctx, "%"PRIi64":%u:%s.%s:%s:%" PRIu32 ":%s:%s",
+        sbus_req->sender->uid, sbus_req->type, sbus_req->interface, sbus_req->member,
+        sbus_req->path, args->arg0, args->arg1, args->arg2);
+}
+
+const char *
+_sbus_sss_key_usu_0_1
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_usu *args)
+{
+    if (sbus_req->sender == NULL) {
+        return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s:%" PRIu32 ":%s",
+            sbus_req->type, sbus_req->interface, sbus_req->member,
+            sbus_req->path, args->arg0, args->arg1);
+    }
+
+    return talloc_asprintf(mem_ctx, "%"PRIi64":%u:%s.%s:%s:%" PRIu32 ":%s",
+        sbus_req->sender->uid, sbus_req->type, sbus_req->interface, sbus_req->member,
+        sbus_req->path, args->arg0, args->arg1);
+}
+
+const char *
+_sbus_sss_key_uusssu_0_1_2_3_4
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_uusssu *args)
+{
+    if (sbus_req->sender == NULL) {
+        return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s:%" PRIu32 ":%" PRIu32 ":%s:%s:%s",
+            sbus_req->type, sbus_req->interface, sbus_req->member,
+            sbus_req->path, args->arg0, args->arg1, args->arg2, args->arg3, args->arg4);
+    }
+
+    return talloc_asprintf(mem_ctx, "%"PRIi64":%u:%s.%s:%s:%" PRIu32 ":%" PRIu32 ":%s:%s:%s",
+        sbus_req->sender->uid, sbus_req->type, sbus_req->interface, sbus_req->member,
+        sbus_req->path, args->arg0, args->arg1, args->arg2, args->arg3, args->arg4);
+}
+
+const char *
+_sbus_sss_key_uusu_0_1_2
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_uusu *args)
+{
+    if (sbus_req->sender == NULL) {
+        return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s:%" PRIu32 ":%" PRIu32 ":%s",
+            sbus_req->type, sbus_req->interface, sbus_req->member,
+            sbus_req->path, args->arg0, args->arg1, args->arg2);
+    }
+
+    return talloc_asprintf(mem_ctx, "%"PRIi64":%u:%s.%s:%s:%" PRIu32 ":%" PRIu32 ":%s",
+        sbus_req->sender->uid, sbus_req->type, sbus_req->interface, sbus_req->member,
+        sbus_req->path, args->arg0, args->arg1, args->arg2);
+}
+
+const char *
+_sbus_sss_key_uuusu_0_1_2_3
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_uuusu *args)
+{
+    if (sbus_req->sender == NULL) {
+        return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s:%" PRIu32 ":%" PRIu32 ":%" PRIu32 ":%s",
+            sbus_req->type, sbus_req->interface, sbus_req->member,
+            sbus_req->path, args->arg0, args->arg1, args->arg2, args->arg3);
+    }
+
+    return talloc_asprintf(mem_ctx, "%"PRIi64":%u:%s.%s:%s:%" PRIu32 ":%" PRIu32 ":%" PRIu32 ":%s",
+        sbus_req->sender->uid, sbus_req->type, sbus_req->interface, sbus_req->member,
+        sbus_req->path, args->arg0, args->arg1, args->arg2, args->arg3);
+}
diff --git a/src/sss_iface/sbus_sss_keygens.h b/src/sss_iface/sbus_sss_keygens.h
new file mode 100644
index 0000000..7e42c2c
--- /dev/null
+++ b/src/sss_iface/sbus_sss_keygens.h
@@ -0,0 +1,81 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SBUS_SSS_KEYGENS_H_
+#define _SBUS_SSS_KEYGENS_H_
+
+#include <talloc.h>
+
+#include "sbus/sbus_request.h"
+#include "sss_iface/sbus_sss_arguments.h"
+
+const char *
+_sbus_sss_key_
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req);
+
+const char *
+_sbus_sss_key_s_0
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_s *args);
+
+const char *
+_sbus_sss_key_u_0
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_u *args);
+
+const char *
+_sbus_sss_key_ussu_0_1
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_ussu *args);
+
+const char *
+_sbus_sss_key_ussu_0_1_2
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_ussu *args);
+
+const char *
+_sbus_sss_key_usu_0_1
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_usu *args);
+
+const char *
+_sbus_sss_key_uusssu_0_1_2_3_4
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_uusssu *args);
+
+const char *
+_sbus_sss_key_uusu_0_1_2
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_uusu *args);
+
+const char *
+_sbus_sss_key_uuusu_0_1_2_3
+   (TALLOC_CTX *mem_ctx,
+    struct sbus_request *sbus_req,
+    struct _sbus_sss_invoker_args_uuusu *args);
+
+#endif /* _SBUS_SSS_KEYGENS_H_ */
diff --git a/src/sss_iface/sbus_sss_server.h b/src/sss_iface/sbus_sss_server.h
new file mode 100644
index 0000000..cc8639a
--- /dev/null
+++ b/src/sss_iface/sbus_sss_server.h
@@ -0,0 +1,27 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SBUS_SSS_SERVER_H_
+#define _SBUS_SSS_SERVER_H_
+
+#include "sbus/sbus.h"
+#include "sbus/sbus_interface.h"
+#include "sss_iface/sbus_sss_interface.h"
+
+#endif /* _SBUS_SSS_SERVER_H_ */
diff --git a/src/sss_iface/sbus_sss_symbols.c b/src/sss_iface/sbus_sss_symbols.c
new file mode 100644
index 0000000..90454dc
--- /dev/null
+++ b/src/sss_iface/sbus_sss_symbols.c
@@ -0,0 +1,495 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 "sbus/sbus_interface_declarations.h"
+#include "sss_iface/sbus_sss_symbols.h"
+
+const struct sbus_method_arguments
+_sbus_sss_args_org_freedesktop_FleetCommanderClient_ProcessSSSDFiles = {
+    .input = (const struct sbus_argument[]){
+        {.type = "u", .name = "uid"},
+        {.type = "s", .name = "user_dir"},
+        {.type = "q", .name = "prio"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_org_freedesktop_systemd1_Manager_RestartUnit = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "name"},
+        {.type = "s", .name = "mode"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "o", .name = "job"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_org_freedesktop_systemd1_Manager_StartUnit = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "name"},
+        {.type = "s", .name = "mode"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "o", .name = "job"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_org_freedesktop_systemd1_Manager_StopUnit = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "name"},
+        {.type = "s", .name = "mode"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "o", .name = "job"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_AccessControl_RefreshRules = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Autofs_Enumerate = {
+    .input = (const struct sbus_argument[]){
+        {.type = "u", .name = "dp_flags"},
+        {.type = "s", .name = "mapname"},
+        {.type = "u", .name = "cli_id"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Autofs_GetEntry = {
+    .input = (const struct sbus_argument[]){
+        {.type = "u", .name = "dp_flags"},
+        {.type = "s", .name = "mapname"},
+        {.type = "s", .name = "entryname"},
+        {.type = "u", .name = "cli_id"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Autofs_GetMap = {
+    .input = (const struct sbus_argument[]){
+        {.type = "u", .name = "dp_flags"},
+        {.type = "s", .name = "mapname"},
+        {.type = "u", .name = "cli_id"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Backend_IsOnline = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "domain_name"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "b", .name = "status"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Client_Register = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "Name"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Failover_ActiveServer = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "service_name"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "s", .name = "server"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Failover_ListServers = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "service_name"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "as", .name = "servers"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Failover_ListServices = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "domain_name"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "as", .name = "services"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_ProxyChild_Auth_PAM = {
+    .input = (const struct sbus_argument[]){
+        {.type = "issssssuayuayiu", .name = "pam_data"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "uua(uay)", .name = "pam_response"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_ProxyChild_Client_Register = {
+    .input = (const struct sbus_argument[]){
+        {.type = "u", .name = "ID"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_Responder_Domain_SetActive = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "name"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_Responder_Domain_SetInconsistent = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "name"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_Responder_NegativeCache_ResetGroups = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_Responder_NegativeCache_ResetUsers = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_getAccountDomain = {
+    .input = (const struct sbus_argument[]){
+        {.type = "u", .name = "dp_flags"},
+        {.type = "u", .name = "entry_type"},
+        {.type = "s", .name = "filter"},
+        {.type = "u", .name = "cli_id"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "q", .name = "dp_error"},
+        {.type = "u", .name = "error"},
+        {.type = "s", .name = "domain_name"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_getAccountInfo = {
+    .input = (const struct sbus_argument[]){
+        {.type = "u", .name = "dp_flags"},
+        {.type = "u", .name = "entry_type"},
+        {.type = "s", .name = "filter"},
+        {.type = "s", .name = "domain"},
+        {.type = "s", .name = "extra"},
+        {.type = "u", .name = "cli_id"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "q", .name = "dp_error"},
+        {.type = "u", .name = "error"},
+        {.type = "s", .name = "error_message"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_getDomains = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "domain_hint"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "q", .name = "dp_error"},
+        {.type = "u", .name = "error"},
+        {.type = "s", .name = "error_message"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_hostHandler = {
+    .input = (const struct sbus_argument[]){
+        {.type = "u", .name = "dp_flags"},
+        {.type = "s", .name = "name"},
+        {.type = "s", .name = "alias"},
+        {.type = "u", .name = "cli_id"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "q", .name = "dp_error"},
+        {.type = "u", .name = "error"},
+        {.type = "s", .name = "error_message"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_pamHandler = {
+    .input = (const struct sbus_argument[]){
+        {.type = "issssssuayuayiu", .name = "pam_data"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "uua(uay)", .name = "pam_response"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_resolverHandler = {
+    .input = (const struct sbus_argument[]){
+        {.type = "u", .name = "dp_flags"},
+        {.type = "u", .name = "entry_type"},
+        {.type = "u", .name = "filter_type"},
+        {.type = "s", .name = "filter_value"},
+        {.type = "u", .name = "cli_id"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "q", .name = "dp_error"},
+        {.type = "u", .name = "error"},
+        {.type = "s", .name = "error_message"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_sudoHandler = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "q", .name = "dp_error"},
+        {.type = "u", .name = "error"},
+        {.type = "s", .name = "error_message"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_monitor_RegisterService = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "name"},
+        {.type = "q", .name = "version"},
+        {.type = "q", .name = "type"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {.type = "q", .name = "monitor_version"},
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllGroups = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllInitgroups = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllUsers = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_nss_MemoryCache_InvalidateGroupById = {
+    .input = (const struct sbus_argument[]){
+        {.type = "u", .name = "gid"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_nss_MemoryCache_UpdateInitgroups = {
+    .input = (const struct sbus_argument[]){
+        {.type = "s", .name = "user"},
+        {.type = "s", .name = "domain"},
+        {.type = "au", .name = "groups"},
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_clearEnumCache = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_clearMemcache = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_clearNegcache = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_goOffline = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_resetOffline = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_rotateLogs = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
+
+const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_sysbusReconnect = {
+    .input = (const struct sbus_argument[]){
+        {NULL}
+    },
+    .output = (const struct sbus_argument[]){
+        {NULL}
+    }
+};
diff --git a/src/sss_iface/sbus_sss_symbols.h b/src/sss_iface/sbus_sss_symbols.h
new file mode 100644
index 0000000..0a9b1b8
--- /dev/null
+++ b/src/sss_iface/sbus_sss_symbols.h
@@ -0,0 +1,142 @@
+/*
+    Generated by sbus code generator
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SBUS_SSS_SYMBOLS_H_
+#define _SBUS_SSS_SYMBOLS_H_
+
+#include "sbus/sbus_interface_declarations.h"
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_org_freedesktop_FleetCommanderClient_ProcessSSSDFiles;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_org_freedesktop_systemd1_Manager_RestartUnit;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_org_freedesktop_systemd1_Manager_StartUnit;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_org_freedesktop_systemd1_Manager_StopUnit;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_AccessControl_RefreshRules;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Autofs_Enumerate;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Autofs_GetEntry;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Autofs_GetMap;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Backend_IsOnline;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Client_Register;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Failover_ActiveServer;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Failover_ListServers;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_DataProvider_Failover_ListServices;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_ProxyChild_Auth_PAM;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_ProxyChild_Client_Register;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_Responder_Domain_SetActive;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_Responder_Domain_SetInconsistent;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_Responder_NegativeCache_ResetGroups;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_Responder_NegativeCache_ResetUsers;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_getAccountDomain;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_getAccountInfo;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_getDomains;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_hostHandler;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_pamHandler;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_resolverHandler;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_dataprovider_sudoHandler;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_monitor_RegisterService;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllGroups;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllInitgroups;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllUsers;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_nss_MemoryCache_InvalidateGroupById;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_nss_MemoryCache_UpdateInitgroups;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_clearEnumCache;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_clearMemcache;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_clearNegcache;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_goOffline;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_resetOffline;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_rotateLogs;
+
+extern const struct sbus_method_arguments
+_sbus_sss_args_sssd_service_sysbusReconnect;
+
+#endif /* _SBUS_SSS_SYMBOLS_H_ */
diff --git a/src/sss_iface/sss_iface.c b/src/sss_iface/sss_iface.c
new file mode 100644
index 0000000..5711f2d
--- /dev/null
+++ b/src/sss_iface/sss_iface.c
@@ -0,0 +1,193 @@
+/*
+    Authors:
+        Pavel Březina <pbrezina@redhat.com>
+
+    Copyright (C) 2018 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 <unistd.h>
+#include <sys/stat.h>
+
+#include "util/util.h"
+#include "sbus/sbus.h"
+#include "sbus/sbus_opath.h"
+#include "sss_iface/sss_iface_async.h"
+
+char *
+sss_iface_domain_address(TALLOC_CTX *mem_ctx,
+                         struct sss_domain_info *domain)
+{
+    struct sss_domain_info *head;
+
+    /* There is only one bus that belongs to the top level domain. */
+    head = get_domains_head(domain);
+
+    return talloc_asprintf(mem_ctx, SSS_BACKEND_ADDRESS, head->name);
+}
+
+char *
+sss_iface_domain_bus(TALLOC_CTX *mem_ctx,
+                     struct sss_domain_info *domain)
+{
+    struct sss_domain_info *head;
+    char *safe_name;
+    char *bus_name;
+
+
+    /* There is only one bus that belongs to the top level domain. */
+    head = get_domains_head(domain);
+
+    safe_name = sbus_opath_escape(mem_ctx, head->name);
+    if (safe_name == NULL) {
+        return NULL;
+    }
+
+    /* Parts of bus names must not start with digit thus we concatenate
+     * the name with underscore instead of period. */
+    bus_name = talloc_asprintf(mem_ctx, "sssd.domain_%s", safe_name);
+    talloc_free(safe_name);
+
+    return bus_name;
+}
+
+char *
+sss_iface_proxy_bus(TALLOC_CTX *mem_ctx,
+                    uint32_t id)
+{
+    /* Parts of bus names must not start with digit thus we concatenate
+     * the name with underscore instead of period. */
+    return talloc_asprintf(mem_ctx, "sssd.proxy_%"PRIu32, id);
+}
+
+errno_t
+sss_iface_connect_address(TALLOC_CTX *mem_ctx,
+                          struct tevent_context *ev,
+                          const char *conn_name,
+                          const char *address,
+                          time_t *last_request_time,
+                          struct sbus_connection **_conn)
+{
+    struct sbus_connection *conn;
+    const char *filename;
+    errno_t ret;
+    uid_t check_uid;
+    gid_t check_gid;
+
+    if (address == NULL) {
+        return EINVAL;
+    }
+
+    filename = strchr(address, '/');
+    if (filename == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "Unexpected dbus address [%s].\n", address);
+        return EIO;
+    }
+
+    check_uid = geteuid();
+    check_gid = getegid();
+
+    /* Ignore ownership checks when the server runs as root. This is the
+     * case when privileged monitor is setting up sockets for unprivileged
+     * responders */
+    if (check_uid == 0) check_uid = -1;
+    if (check_gid == 0) check_gid = -1;
+
+    ret = check_file(filename, check_uid, check_gid,
+                     S_IFSOCK|S_IRUSR|S_IWUSR, 0, NULL, true);
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "check_file failed for [%s].\n", filename);
+        return EIO;
+    }
+
+    conn = sbus_connect_private(mem_ctx, ev, address,
+                                conn_name, last_request_time);
+    if (conn == NULL) { /* most probably sbus_dbus_connect_address() failed */
+        return EFAULT;
+    }
+
+    *_conn = conn;
+
+    return EOK;
+}
+
+static void
+sss_monitor_service_init_done(struct tevent_req *req);
+
+errno_t
+sss_monitor_service_init(TALLOC_CTX *mem_ctx,
+                         struct tevent_context *ev,
+                         const char *conn_name,
+                         const char *svc_name,
+                         uint16_t svc_version,
+                         uint16_t svc_type,
+                         time_t *last_request_time,
+                         struct sbus_connection **_conn)
+{
+    struct sbus_connection *conn;
+    struct tevent_req *req;
+    errno_t ret;
+
+    ret = sss_iface_connect_address(mem_ctx, ev, conn_name,
+                                    SSS_MONITOR_ADDRESS,
+                                    last_request_time, &conn);
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to connect to monitor sbus server "
+              "[%d]: %s\n", ret, sss_strerror(ret));
+        return ret;
+    }
+
+    req = sbus_call_monitor_RegisterService_send(conn, conn, SSS_BUS_MONITOR,
+                                                 SSS_BUS_PATH, svc_name,
+                                                 svc_version, svc_type);
+    if (req == NULL) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create tevent request!\n");
+        ret = ENOMEM;
+        goto done;
+    }
+
+    tevent_req_set_callback(req, sss_monitor_service_init_done, conn);
+
+    *_conn = conn;
+
+    ret = EOK;
+
+done:
+    if (ret != EOK) {
+        talloc_free(conn);
+    }
+
+    return ret;
+}
+
+static void
+sss_monitor_service_init_done(struct tevent_req *req)
+{
+    uint16_t version;
+    errno_t ret;
+
+    ret = sbus_call_monitor_RegisterService_recv(req, &version);
+    talloc_zfree(req);
+
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to register client in monitor "
+              "[%d]: %s\n", ret, sss_strerror(ret));
+        return;
+    }
+
+    DEBUG(SSSDBG_CONF_SETTINGS, "Got id ack and version (%d) from Monitor\n",
+          version);
+}
diff --git a/src/sss_iface/sss_iface.h b/src/sss_iface/sss_iface.h
new file mode 100644
index 0000000..b705958
--- /dev/null
+++ b/src/sss_iface/sss_iface.h
@@ -0,0 +1,83 @@
+/*
+    Authors:
+        Pavel Březina <pbrezina@redhat.com>
+
+    Copyright (C) 2018 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SSS_IFACE_H_
+#define _SSS_IFACE_H_
+
+#include "config.h"
+
+#include <stdint.h>
+#include <talloc.h>
+
+#include "confdb/confdb.h"
+#include "providers/data_provider_req.h"
+#include "providers/data_provider/dp_flags.h"
+
+#define SSS_MONITOR_ADDRESS "unix:path=" PIPE_PATH "/private/sbus-monitor"
+#define SSS_BACKEND_ADDRESS "unix:path=" PIPE_PATH "/private/sbus-dp_%s"
+
+#define SSS_BUS_MONITOR     "sssd.monitor"
+#define SSS_BUS_AUTOFS      "sssd.autofs"
+#define SSS_BUS_IFP         "sssd.ifp"
+#define SSS_BUS_NSS         "sssd.nss"
+#define SSS_BUS_PAC         "sssd.pac"
+#define SSS_BUS_PAM         "sssd.pam"
+#define SSS_BUS_SSH         "sssd.ssh"
+#define SSS_BUS_SUDO        "sssd.sudo"
+
+#define SSS_BUS_PATH        "/sssd"
+
+#define NSS_SBUS_SERVICE_NAME "nss"
+#define NSS_SBUS_SERVICE_VERSION 0x0001
+#define SSS_PAM_SBUS_SERVICE_NAME "pam"
+#define SSS_PAM_SBUS_SERVICE_VERSION 0x0001
+#define SSS_SUDO_SBUS_SERVICE_NAME "sudo"
+#define SSS_SUDO_SBUS_SERVICE_VERSION 0x0001
+#define SSS_AUTOFS_SBUS_SERVICE_NAME    "autofs"
+#define SSS_AUTOFS_SBUS_SERVICE_VERSION 0x0001
+#define SSS_SSH_SBUS_SERVICE_NAME    "ssh"
+#define SSS_SSH_SBUS_SERVICE_VERSION 0x0001
+#define SSS_IFP_SBUS_SERVICE_NAME    "ifp"
+#define SSS_IFP_SBUS_SERVICE_VERSION 0x0001
+#define PAC_SBUS_SERVICE_NAME "pac"
+#define PAC_SBUS_SERVICE_VERSION 0x0001
+
+/**
+ * Return domain address.
+ */
+char *
+sss_iface_domain_address(TALLOC_CTX *mem_ctx,
+                         struct sss_domain_info *domain);
+
+/**
+ * Return domain bus name.
+ */
+char *
+sss_iface_domain_bus(TALLOC_CTX *mem_ctx,
+                     struct sss_domain_info *domain);
+
+/**
+ * Return proxy child bus name.
+ */
+char *
+sss_iface_proxy_bus(TALLOC_CTX *mem_ctx,
+                    uint32_t id);
+
+#endif /* _SSS_IFACE_H_ */
diff --git a/src/sss_iface/sss_iface.xml b/src/sss_iface/sss_iface.xml
new file mode 100644
index 0000000..82c65aa
--- /dev/null
+++ b/src/sss_iface/sss_iface.xml
@@ -0,0 +1,202 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+    <interface name="sssd.monitor">
+        <annotation name="codegen.Name" value="monitor" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="RegisterService">
+            <arg type="s" name="name" direction="in" />
+            <arg type="q" name="version" direction="in" />
+            <arg type="q" name="type" direction="in" />
+            <arg type="q" name="monitor_version" direction="out" />
+        </method>
+    </interface>
+
+    <interface name="sssd.service">
+        <annotation name="codegen.Name" value="service" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="goOffline" />
+        <method name="resetOffline" />
+        <method name="rotateLogs" />
+        <method name="clearMemcache" />
+        <method name="clearNegcache" />
+        <method name="clearEnumCache" />
+        <method name="sysbusReconnect" />
+        <property name="debug_level" type="u" access="readwrite">
+            <annotation name="codegen.SyncCaller" value="true" />
+            <annotation name="codegen.AsyncCaller" value="false" />
+        </property>
+    </interface>
+
+    <interface name="sssd.ProxyChild.Client">
+        <annotation name="codegen.Name" value="proxy_client" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="Register">
+            <arg name="ID" type="u" direction="in" />
+        </method>
+    </interface>
+
+    <interface name="sssd.ProxyChild.Auth">
+        <annotation name="codegen.Name" value="proxy_auth" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="PAM">
+            <arg name="pam_data" type="pam_data" direction="in" />
+            <arg name="pam_response" type="pam_response" direction="out" />
+        </method>
+    </interface>
+
+    <interface name="sssd.DataProvider.Client">
+        <annotation name="codegen.Name" value="dp_client" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="Register">
+            <arg name="Name" type="s" direction="in" />
+        </method>
+    </interface>
+
+    <interface name="sssd.DataProvider.Backend">
+        <annotation name="codegen.Name" value="dp_backend" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="IsOnline">
+            <arg name="domain_name" type="s" direction="in" key="1" />
+            <arg name="status" type="b" direction="out" />
+        </method>
+    </interface>
+
+    <interface name="sssd.DataProvider.Failover">
+        <annotation name="codegen.Name" value="dp_failover" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="ListServices">
+            <arg name="domain_name" type="s" direction="in" key="1" />
+            <arg name="services" type="as" direction="out" />
+        </method>
+        <method name="ActiveServer">
+            <arg name="service_name" type="s" direction="in" key="1" />
+            <arg name="server" type="s" direction="out" />
+        </method>
+        <method name="ListServers">
+            <arg name="service_name" type="s" direction="in" key="1" />
+            <arg name="servers" type="as" direction="out" />
+        </method>
+    </interface>
+
+    <interface name="sssd.DataProvider.AccessControl">
+        <annotation name="codegen.Name" value="dp_access" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="RefreshRules" key="True" />
+    </interface>
+
+    <interface name="sssd.DataProvider.Autofs">
+        <annotation name="codegen.Name" value="dp_autofs" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="GetMap">
+            <arg name="dp_flags" type="u" direction="in" key="1" />
+            <arg name="mapname" type="s" direction="in" key="2" />
+            <arg name="cli_id" type="u" direction="in" />
+        </method>
+        <method name="GetEntry">
+            <arg name="dp_flags" type="u" direction="in" key="1" />
+            <arg name="mapname" type="s" direction="in" key="2" />
+            <arg name="entryname" type="s" direction="in" key="3" />
+            <arg name="cli_id" type="u" direction="in" />
+        </method>
+        <method name="Enumerate">
+            <arg name="dp_flags" type="u" direction="in" key="1" />
+            <arg name="mapname" type="s" direction="in" key="2" />
+            <arg name="cli_id" type="u" direction="in" />
+        </method>
+    </interface>
+
+    <interface name="sssd.dataprovider">
+        <annotation name="codegen.Name" value="dp_dp" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="pamHandler">
+            <arg name="pam_data" type="pam_data" direction="in" />
+            <arg name="pam_response" type="pam_response" direction="out" />
+        </method>
+        <method name="sudoHandler">
+            <annotation name="codegen.CustomInputHandler" value="true" />
+            <arg name="dp_error" type="q" direction="out" />
+            <arg name="error" type="u" direction="out" />
+            <arg name="error_message" type="s" direction="out" />
+        </method>
+        <method name="hostHandler">
+            <arg name="dp_flags" type="u" direction="in" key="1" />
+            <arg name="name" type="s" direction="in" key="2" />
+            <arg name="alias" type="s" direction="in" />
+            <arg name="cli_id" type="u" direction="in" />
+            <arg name="dp_error" type="q" direction="out" />
+            <arg name="error" type="u" direction="out" />
+            <arg name="error_message" type="s" direction="out" />
+        </method>
+        <method name="resolverHandler">
+            <arg name="dp_flags" type="u" direction="in" key="1" />
+            <arg name="entry_type" type="u" direction="in" key="2" />
+            <arg name="filter_type" type="u" direction="in" key="3" />
+            <arg name="filter_value" type="s" direction="in" key="4" />
+            <arg name="cli_id" type="u" direction="in" />
+            <arg name="dp_error" type="q" direction="out" />
+            <arg name="error" type="u" direction="out" />
+            <arg name="error_message" type="s" direction="out" />
+        </method>
+        <method name="getDomains">
+            <arg name="domain_hint" type="s" direction="in" key="1" />
+            <arg name="dp_error" type="q" direction="out" />
+            <arg name="error" type="u" direction="out" />
+            <arg name="error_message" type="s" direction="out" />
+        </method>
+        <method name="getAccountInfo">
+            <arg name="dp_flags" type="u" direction="in" key="1" />
+            <arg name="entry_type" type="u" direction="in" key="2" />
+            <arg name="filter" type="s" direction="in" key="3" />
+            <arg name="domain" type="s" direction="in" key="4" />
+            <arg name="extra" type="s" direction="in" key="5" />
+            <arg name="cli_id" type="u" direction="in" />
+            <arg name="dp_error" type="q" direction="out" />
+            <arg name="error" type="u" direction="out" />
+            <arg name="error_message" type="s" direction="out" />
+        </method>
+        <method name="getAccountDomain">
+            <arg name="dp_flags" type="u" direction="in" key="1" />
+            <arg name="entry_type" type="u" direction="in" key="2" />
+            <arg name="filter" type="s" direction="in" key="3" />
+            <arg name="cli_id" type="u" direction="in" />
+            <arg name="dp_error" type="q" direction="out" />
+            <arg name="error" type="u" direction="out" />
+            <arg name="domain_name" type="s" direction="out" />
+        </method>
+    </interface>
+
+    <interface name="sssd.Responder.Domain">
+        <annotation name="codegen.Name" value="resp_domain" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="SetActive">
+            <arg name="name" type="s" direction="in" key="1" />
+        </method>
+        <method name="SetInconsistent">
+            <arg name="name" type="s" direction="in" key="1" />
+        </method>
+    </interface>
+
+    <interface name="sssd.Responder.NegativeCache">
+        <annotation name="codegen.Name" value="resp_negcache" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="ResetUsers" key="True" />
+        <method name="ResetGroups" key="True" />
+    </interface>
+
+    <interface name="sssd.nss.MemoryCache">
+        <annotation name="codegen.Name" value="nss_memcache" />
+        <annotation name="codegen.SyncCaller" value="false" />
+        <method name="UpdateInitgroups">
+            <arg name="user" type="s" direction="in" />
+            <arg name="domain" type="s" direction="in" />
+            <arg name="groups" type="au" direction="in" />
+        </method>
+        <method name="InvalidateAllUsers" key="True" />
+        <method name="InvalidateAllGroups" key="True" />
+        <method name="InvalidateAllInitgroups" key="True" />
+        <method name="InvalidateGroupById" key="True">
+            <arg name="gid" type="u" direction="in" key="1" />
+        </method>
+    </interface>
+</node>
diff --git a/src/sss_iface/sss_iface_async.h b/src/sss_iface/sss_iface_async.h
new file mode 100644
index 0000000..6843356
--- /dev/null
+++ b/src/sss_iface/sss_iface_async.h
@@ -0,0 +1,61 @@
+/*
+    Authors:
+        Pavel Březina <pbrezina@redhat.com>
+
+    Copyright (C) 2018 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SSS_IFACE_ASYNC_H_
+#define _SSS_IFACE_ASYNC_H_
+
+#include <tevent.h>
+#include <time.h>
+
+#include "sss_iface/sbus_sss_server.h"
+#include "sss_iface/sbus_sss_client_async.h"
+#include "sss_iface/sss_iface.h"
+
+/**
+ * Check socket and connect to private sbus server.
+ */
+errno_t
+sss_iface_connect_address(TALLOC_CTX *mem_ctx,
+                          struct tevent_context *ev,
+                          const char *conn_name,
+                          const char *address,
+                          time_t *last_request_time,
+                          struct sbus_connection **_conn);
+
+enum mt_svc_type {
+    MT_SVC_SERVICE,
+    MT_SVC_PROVIDER
+};
+
+/**
+ * Connect to monitor sbus server and register standard service interface
+ * on SSS_BUS_PATH object path.
+ */
+errno_t
+sss_monitor_service_init(TALLOC_CTX *mem_ctx,
+                         struct tevent_context *ev,
+                         const char *conn_name,
+                         const char *svc_name,
+                         uint16_t svc_version,
+                         uint16_t svc_type,
+                         time_t *last_request_time,
+                         struct sbus_connection **_conn);
+
+#endif /* _SSS_IFACE_ASYNC_H_ */
diff --git a/src/sss_iface/sss_iface_sync.h b/src/sss_iface/sss_iface_sync.h
new file mode 100644
index 0000000..bb0a5fc
--- /dev/null
+++ b/src/sss_iface/sss_iface_sync.h
@@ -0,0 +1,27 @@
+/*
+    Authors:
+        Pavel Březina <pbrezina@redhat.com>
+
+    Copyright (C) 2018 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SSS_IFACE_SYNC_H_
+#define _SSS_IFACE_SYNC_H_
+
+#include "sss_iface/sbus_sss_client_sync.h"
+#include "sss_iface/sss_iface.h"
+
+#endif /* _SSS_IFACE_SYNC_H_ */
diff --git a/src/sss_iface/sss_iface_types.c b/src/sss_iface/sss_iface_types.c
new file mode 100644
index 0000000..978f4ac
--- /dev/null
+++ b/src/sss_iface/sss_iface_types.c
@@ -0,0 +1,442 @@
+/*
+    Authors:
+        Pavel Březina <pbrezina@redhat.com>
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 <errno.h>
+#include <string.h>
+#include <stdint.h>
+#include <talloc.h>
+#include <dbus/dbus.h>
+
+#include "util/util.h"
+#include "util/sss_utf8.h"
+#include "sss_iface/sss_iface_types.h"
+#include "sbus/interface/sbus_iterator_readers.h"
+#include "sbus/interface/sbus_iterator_writers.h"
+
+/**
+ * D-Bus signature: issssssuayuayiu
+ */
+errno_t sbus_iterator_read_pam_data(TALLOC_CTX *mem_ctx,
+                                    DBusMessageIter *iterator,
+                                    struct pam_data **_pd)
+{
+    struct pam_data *pd;
+    uint32_t authtok_type;
+    uint8_t *authtok_data;
+    uint32_t new_authtok_type;
+    uint8_t *new_authtok_data;
+    errno_t ret;
+
+    pd = create_pam_data(mem_ctx);
+    if (pd == NULL) {
+        return ENOMEM;
+    }
+
+    ret = sbus_iterator_read_i(iterator, &pd->cmd);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_S(pd, iterator, &pd->user);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_S(pd, iterator, &pd->domain);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_S(pd, iterator, &pd->service);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_S(pd, iterator, &pd->tty);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_S(pd, iterator, &pd->ruser);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_S(pd, iterator, &pd->rhost);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_u(iterator, &authtok_type);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_ay(pd, iterator, &authtok_data);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_u(iterator, &new_authtok_type);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_ay(pd, iterator, &new_authtok_data);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_i(iterator, &pd->priv);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_u(iterator, &pd->cli_pid);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_u(iterator, &pd->child_pid);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_read_u(iterator, &pd->client_id_num);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    pd->authtok = sss_authtok_new(pd);
+    if (pd->authtok == NULL) {
+        ret = ENOMEM;
+        goto done;
+    }
+
+    pd->newauthtok = sss_authtok_new(pd);
+    if (pd->newauthtok == NULL) {
+        ret = ENOMEM;
+        goto done;
+    }
+
+    ret = sss_authtok_set(pd->authtok, authtok_type, authtok_data,
+                          talloc_array_length(authtok_data));
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Failed to set auth token [%d]: %s\n",
+              ret, sss_strerror(ret));
+        goto done;
+    }
+
+    ret = sss_authtok_set(pd->newauthtok, new_authtok_type, new_authtok_data,
+                          talloc_array_length(new_authtok_data));
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Failed to set auth token [%d]: %s\n",
+              ret, sss_strerror(ret));
+        goto done;
+    }
+
+    *_pd = pd;
+
+    ret = EOK;
+
+done:
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to read pam data [%d]: %s\n",
+              ret, sss_strerror(ret));
+        talloc_free(pd);
+    }
+
+    return ret;
+}
+
+/**
+ * D-Bus signature: issssssuayuayiu
+ */
+errno_t sbus_iterator_write_pam_data(DBusMessageIter *iterator,
+                                     struct pam_data *pd)
+{
+    uint32_t authtok_type;
+    uint8_t *authtok_data;
+    int authtok_length;
+    uint32_t new_authtok_type;
+    uint8_t *new_authtok_data;
+    int new_authtok_length;
+    errno_t ret;
+
+    authtok_type = (uint32_t)sss_authtok_get_type(pd->authtok);
+    authtok_data = sss_authtok_get_data(pd->authtok);
+    authtok_length = sss_authtok_get_size(pd->authtok);
+    new_authtok_type = (uint32_t)sss_authtok_get_type(pd->newauthtok);
+    new_authtok_data = sss_authtok_get_data(pd->newauthtok);
+    new_authtok_length = sss_authtok_get_size(pd->newauthtok);
+
+    ret = sbus_iterator_write_i(iterator, pd->cmd);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_S(iterator, pd->user);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_S(iterator, pd->domain);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_S(iterator, pd->service);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_S(iterator, pd->tty);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_S(iterator, pd->ruser);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_S(iterator, pd->rhost);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_u(iterator, authtok_type);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_basic_array_len(iterator, DBUS_TYPE_BYTE, uint8_t,
+                                              authtok_data, authtok_length);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_u(iterator, new_authtok_type);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_basic_array_len(iterator, DBUS_TYPE_BYTE, uint8_t,
+                                              new_authtok_data, new_authtok_length);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_i(iterator, pd->priv);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_u(iterator, pd->cli_pid);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_u(iterator, pd->child_pid);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_u(iterator, pd->client_id_num);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = EOK;
+
+done:
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to write pam data [%d]: %s\n",
+              ret, sss_strerror(ret));
+    }
+
+    return ret;
+}
+
+/**
+ * D-Bus signature: uua(uay)
+ */
+errno_t sbus_iterator_read_pam_response(TALLOC_CTX *mem_ctx,
+                                        DBusMessageIter *iterator,
+                                        struct pam_data **_pd)
+{
+    struct pam_data *pd;
+    DBusMessageIter array_iter;
+    DBusMessageIter struct_iter;
+    uint32_t pam_status;
+    uint32_t account_locked;
+    uint32_t resp_type;
+    uint8_t *resp_data;
+    errno_t ret;
+    int type;
+
+    pd = create_pam_data(mem_ctx);
+    if (pd == NULL) {
+        return ENOMEM;
+    }
+
+    ret = sbus_iterator_read_u(iterator, &pam_status);
+    if (ret != EOK) {
+        goto done;
+    }
+    pd->pam_status = pam_status;
+
+    ret = sbus_iterator_read_u(iterator, &account_locked);
+    if (ret != EOK) {
+        goto done;
+    }
+    pd->account_locked = account_locked;
+
+    type = dbus_message_iter_get_arg_type(iterator);
+    if (type != DBUS_TYPE_ARRAY) {
+        ret = EINVAL;
+        goto done;
+    }
+
+    type = dbus_message_iter_get_element_type(iterator);
+    if (type != DBUS_TYPE_STRUCT) {
+        ret = EINVAL;
+        goto done;
+    }
+
+    dbus_message_iter_recurse(iterator, &array_iter);
+    while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID) {
+        type = dbus_message_iter_get_arg_type(&array_iter);
+        if (type != DBUS_TYPE_STRUCT) {
+            ret = EINVAL;
+            goto done;
+        }
+
+        dbus_message_iter_recurse(&array_iter, &struct_iter);
+
+        ret = sbus_iterator_read_u(&struct_iter, &resp_type);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = sbus_iterator_read_ay(pd, &struct_iter, &resp_data);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = pam_add_response(pd, resp_type, talloc_array_length(resp_data),
+                               resp_data);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        talloc_free(resp_data);
+
+        dbus_message_iter_next(&array_iter);
+    }
+
+    *_pd = pd;
+
+    ret = EOK;
+
+done:
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to read pam data [%d]: %s\n",
+              ret, sss_strerror(ret));
+        talloc_free(pd);
+    }
+
+    return ret;
+}
+
+/**
+ * D-Bus signature: uua(uay)
+ */
+errno_t sbus_iterator_write_pam_response(DBusMessageIter *iterator,
+                                         struct pam_data *pd)
+{
+    struct response_data *resp;
+    DBusMessageIter array_iter;
+    DBusMessageIter struct_iter;
+    dbus_bool_t dbret;
+    errno_t ret;
+
+    ret = sbus_iterator_write_u(iterator, pd->pam_status);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    ret = sbus_iterator_write_u(iterator, pd->account_locked);
+    if (ret != EOK) {
+        goto done;
+    }
+
+    dbret = dbus_message_iter_open_container(iterator, DBUS_TYPE_ARRAY,
+                                             "(uay)", &array_iter);
+    if (!dbret) {
+        ret = EIO;
+        goto done;
+    }
+
+    for (resp = pd->resp_list; resp != NULL; resp = resp->next) {
+        dbret = dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT,
+                                                 NULL, &struct_iter);
+        if (!dbret) {
+            ret = EIO;
+            goto done;
+        }
+
+        ret = sbus_iterator_write_u(&struct_iter, resp->type);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        ret = sbus_iterator_write_basic_array_len(&struct_iter, DBUS_TYPE_BYTE,
+                                              uint8_t, resp->data, resp->len);
+        if (ret != EOK) {
+            goto done;
+        }
+
+        dbret = dbus_message_iter_close_container(&array_iter, &struct_iter);
+        if (!dbret) {
+            dbus_message_iter_abandon_container(&array_iter, &struct_iter);
+            dbus_message_iter_abandon_container(iterator, &array_iter);
+            ret = EIO;
+            goto done;
+        }
+    }
+
+    dbret = dbus_message_iter_close_container(iterator, &array_iter);
+    if (!dbret) {
+        dbus_message_iter_abandon_container(iterator, &array_iter);
+        ret = EIO;
+        goto done;
+    }
+
+    ret = EOK;
+
+done:
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CRIT_FAILURE, "Unable to write pam response [%d]: %s\n",
+              ret, sss_strerror(ret));
+    }
+
+    return ret;
+}
diff --git a/src/sss_iface/sss_iface_types.h b/src/sss_iface/sss_iface_types.h
new file mode 100644
index 0000000..c9b0d5d
--- /dev/null
+++ b/src/sss_iface/sss_iface_types.h
@@ -0,0 +1,43 @@
+/*
+    Authors:
+        Pavel Březina <pbrezina@redhat.com>
+
+    Copyright (C) 2017 Red Hat
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY 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 _SSS_IFACE_CUSTOM_TYPES_H_
+#define _SSS_IFACE_CUSTOM_TYPES_H_
+
+#include <talloc.h>
+#include <dbus/dbus.h>
+
+#include "util/sss_pam_data.h"
+
+errno_t sbus_iterator_read_pam_data(TALLOC_CTX *mem_ctx,
+                                    DBusMessageIter *iterator,
+                                    struct pam_data **_pd);
+
+errno_t sbus_iterator_write_pam_data(DBusMessageIter *iterator,
+                                     struct pam_data *pd);
+
+errno_t sbus_iterator_read_pam_response(TALLOC_CTX *mem_ctx,
+                                        DBusMessageIter *iterator,
+                                        struct pam_data **_pd);
+
+errno_t sbus_iterator_write_pam_response(DBusMessageIter *iterator,
+                                         struct pam_data *pd);
+
+#endif /* _SSS_IFACE_CUSTOM_TYPES_H_ */