diff options
Diffstat (limited to 'src/responder/ifp/ifp_iface')
22 files changed, 10566 insertions, 0 deletions
diff --git a/src/responder/ifp/ifp_iface/ifp_iface.c b/src/responder/ifp/ifp_iface/ifp_iface.c new file mode 100644 index 0000000..cbab470 --- /dev/null +++ b/src/responder/ifp/ifp_iface/ifp_iface.c @@ -0,0 +1,274 @@ +/* + 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 "responder/common/responder.h" +#include "responder/ifp/ifp_private.h" +#include "responder/ifp/ifp_iface/ifp_iface_async.h" +#include "responder/ifp/ifp_cache.h" +#include "responder/ifp/ifp_components.h" +#include "responder/ifp/ifp_domains.h" +#include "responder/ifp/ifp_groups.h" +#include "responder/ifp/ifp_users.h" + +errno_t +ifp_access_check(struct sbus_request *sbus_req, + struct ifp_ctx *ifp_ctx) +{ + uid_t uid; + errno_t ret; + + /* We allow those special cases to access infopipe. */ + if (sbus_req->sender->uid < 0) { + return EOK; + } + + uid = (uid_t)sbus_req->sender->uid; + + ret = check_allowed_uids(uid, + ifp_ctx->rctx->allowed_uids_count, + ifp_ctx->rctx->allowed_uids); + if (ret == EACCES) { + DEBUG(SSSDBG_MINOR_FAILURE, "User %"PRIi64" not in ACL\n", + sbus_req->sender->uid); + return ret; + } else if (ret != EOK) { + DEBUG(SSSDBG_OP_FAILURE, "Cannot check if user %"PRIi64 + "is present in ACL\n", sbus_req->sender->uid); + return ret; + } + + switch (sbus_req->type) { + case SBUS_REQUEST_PROPERTY_GET: + if (strcmp(sbus_req->interface, "org.freedesktop.sssd.infopipe.Users.User") == 0) { + if (!ifp_is_user_attr_allowed(ifp_ctx, sbus_req->property)) { + DEBUG(SSSDBG_TRACE_ALL, "Attribute %s is not allowed\n", + sbus_req->property); + return EACCES; + } + } + break; + default: + return EOK; + } + + return EOK; +} + +errno_t +ifp_register_sbus_interface(struct sbus_connection *conn, + struct ifp_ctx *ctx) +{ + errno_t ret; + + SBUS_INTERFACE(iface_ifp, + org_freedesktop_sssd_infopipe, + SBUS_METHODS( + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe, Ping, ifp_ping, ctx), + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe, ListComponents, ifp_list_components, ctx), + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe, ListResponders, ifp_list_responders, ctx), + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe, ListBackends, ifp_list_backends, ctx), + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe, FindMonitor, ifp_find_monitor, ctx), + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe, FindResponderByName, ifp_find_responder_by_name, ctx), + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe, FindBackendByName, ifp_find_backend_by_name, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe, GetUserAttr, ifp_get_user_attr_send, ifp_get_user_attr_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe, GetUserGroups, ifp_user_get_groups_send, ifp_user_get_groups_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe, FindDomainByName, ifp_find_domain_by_name_send, ifp_find_domain_by_name_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe, ListDomains, ifp_list_domains_send, ifp_list_domains_recv, ctx) + ), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES(SBUS_NO_PROPERTIES) + ); + + SBUS_INTERFACE(iface_ifp_components, + org_freedesktop_sssd_infopipe_Components, + SBUS_METHODS(SBUS_NO_METHODS), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES( + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Components, name, ifp_component_get_name, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Components, debug_level, ifp_component_get_debug_level, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Components, enabled, ifp_component_get_enabled, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Components, type, ifp_component_get_type, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Components, providers, ifp_backend_get_providers, ctx) + ) + ); + + SBUS_INTERFACE(iface_ifp_domains, + org_freedesktop_sssd_infopipe_Domains, + SBUS_METHODS(SBUS_NO_METHODS), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES( + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, name, ifp_dom_get_name, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, provider, ifp_dom_get_provider, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, primary_servers, ifp_dom_get_primary_servers, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, backup_servers, ifp_dom_get_backup_servers, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, min_id, ifp_dom_get_min_id, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, max_id, ifp_dom_get_max_id, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, realm, ifp_dom_get_realm, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, forest, ifp_dom_get_forest, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, login_format, ifp_dom_get_login_format, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, fully_qualified_name_format, ifp_dom_get_fqdn_format, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, enumerable, ifp_dom_get_enumerable, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, use_fully_qualified_names, ifp_dom_get_use_fqdn, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, subdomain, ifp_dom_get_subdomain, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Domains, parent_domain, ifp_dom_get_parent_domain, ctx) + ) + ); + + SBUS_INTERFACE(iface_ifp_domains_domain, + org_freedesktop_sssd_infopipe_Domains_Domain, + SBUS_METHODS( + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Domains_Domain, IsOnline, ifp_domains_domain_is_online_send, ifp_domains_domain_is_online_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Domains_Domain, ListServices, ifp_domains_domain_list_services_send, ifp_domains_domain_list_services_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Domains_Domain, ActiveServer, ifp_domains_domain_active_server_send, ifp_domains_domain_active_server_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Domains_Domain, ListServers, ifp_domains_domain_list_servers_send, ifp_domains_domain_list_servers_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Domains_Domain, RefreshAccessRules, ifp_domains_domain_refresh_access_rules_send, ifp_domains_domain_refresh_access_rules_recv, ctx) + ), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES(SBUS_NO_PROPERTIES) + ); + + SBUS_INTERFACE(iface_ifp_users, + org_freedesktop_sssd_infopipe_Users, + SBUS_METHODS( + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Users, FindByName, ifp_users_find_by_name_send, ifp_users_find_by_name_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Users, FindByID, ifp_users_find_by_id_send, ifp_users_find_by_id_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Users, FindByCertificate, ifp_users_find_by_cert_send, ifp_users_find_by_cert_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Users, ListByCertificate, ifp_users_list_by_cert_send, ifp_users_list_by_cert_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Users, FindByNameAndCertificate, ifp_users_find_by_name_and_cert_send, ifp_users_find_by_name_and_cert_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Users, ListByName, ifp_users_list_by_name_send, ifp_users_list_by_attr_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Users, ListByDomainAndName, ifp_users_list_by_domain_and_name_send, ifp_users_list_by_domain_and_name_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Users, FindByValidCertificate, ifp_users_find_by_valid_cert_send, ifp_users_find_by_valid_cert_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Users, ListByAttr, ifp_users_list_by_attr_send, ifp_users_list_by_attr_recv, ctx) + ), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES(SBUS_NO_PROPERTIES) + ); + + SBUS_INTERFACE(iface_ifp_users_user, + org_freedesktop_sssd_infopipe_Users_User, + SBUS_METHODS(SBUS_NO_METHODS), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES( + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, name, ifp_users_user_get_name, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, uidNumber, ifp_users_user_get_uid_number, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, gidNumber, ifp_users_user_get_gid_number, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, gecos, ifp_users_user_get_gecos, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, homeDirectory, ifp_users_user_get_home_directory, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, loginShell, ifp_users_user_get_login_shell, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, uniqueID, ifp_users_user_get_unique_id, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, groups, ifp_users_user_get_groups, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, domain, ifp_users_user_get_domain, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, domainname, ifp_users_user_get_domainname, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Users_User, extraAttributes, ifp_users_user_get_extra_attributes, ctx) + ) + ); + + SBUS_INTERFACE(iface_ifp_cache_user, + org_freedesktop_sssd_infopipe_Cache, + SBUS_METHODS( + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe_Cache, List, ifp_cache_list_user, ctx), + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe_Cache, ListByDomain, ifp_cache_list_by_domain_user, ctx) + ), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES(SBUS_NO_PROPERTIES) + ); + + SBUS_INTERFACE(iface_ifp_cache_object_user, + org_freedesktop_sssd_infopipe_Cache_Object, + SBUS_METHODS( + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe_Cache_Object, Store, ifp_cache_object_store_user, ctx), + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe_Cache_Object, Remove, ifp_cache_object_remove_user, ctx) + ), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES(SBUS_NO_PROPERTIES) + ); + + SBUS_INTERFACE(iface_ifp_groups, + org_freedesktop_sssd_infopipe_Groups, + SBUS_METHODS( + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Groups, FindByName, ifp_groups_find_by_name_send, ifp_groups_find_by_name_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Groups, FindByID, ifp_groups_find_by_id_send, ifp_groups_find_by_id_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Groups, ListByName, ifp_groups_list_by_name_send, ifp_groups_list_by_name_recv, ctx), + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Groups, ListByDomainAndName, ifp_groups_list_by_domain_and_name_send, ifp_groups_list_by_domain_and_name_recv, ctx) + ), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES(SBUS_NO_PROPERTIES) + ); + + SBUS_INTERFACE(iface_ifp_groups_group, + org_freedesktop_sssd_infopipe_Groups_Group, + SBUS_METHODS( + SBUS_ASYNC(METHOD, org_freedesktop_sssd_infopipe_Groups_Group, UpdateMemberList, ifp_groups_group_update_member_list_send, ifp_groups_group_update_member_list_recv, ctx) + ), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES( + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Groups_Group, name, ifp_groups_group_get_name, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Groups_Group, gidNumber, ifp_groups_group_get_gid_number, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Groups_Group, uniqueID, ifp_groups_group_get_unique_id, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Groups_Group, users, ifp_groups_group_get_users, ctx), + SBUS_SYNC(GETTER, org_freedesktop_sssd_infopipe_Groups_Group, groups, ifp_groups_group_get_groups, ctx) + ) + ); + + SBUS_INTERFACE(iface_ifp_cache_group, + org_freedesktop_sssd_infopipe_Cache, + SBUS_METHODS( + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe_Cache, List, ifp_cache_list_group, ctx), + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe_Cache, ListByDomain, ifp_cache_list_by_domain_group, ctx) + ), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES(SBUS_NO_PROPERTIES) + ); + + SBUS_INTERFACE(iface_ifp_cache_object_group, + org_freedesktop_sssd_infopipe_Cache_Object, + SBUS_METHODS( + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe_Cache_Object, Store, ifp_cache_object_store_group, ctx), + SBUS_SYNC(METHOD, org_freedesktop_sssd_infopipe_Cache_Object, Remove, ifp_cache_object_remove_group, ctx) + ), + SBUS_SIGNALS(SBUS_NO_SIGNALS), + SBUS_PROPERTIES(SBUS_NO_PROPERTIES) + ); + + struct sbus_path paths[] = { + { IFP_PATH, &iface_ifp }, + { IFP_PATH_DOMAINS, &iface_ifp_domains }, + { IFP_PATH_DOMAINS_TREE, &iface_ifp_domains }, + { IFP_PATH_DOMAINS_TREE, &iface_ifp_domains_domain }, + { IFP_PATH_COMPONENTS_TREE, &iface_ifp_components }, + { IFP_PATH_USERS, &iface_ifp_users }, + { IFP_PATH_USERS, &iface_ifp_cache_user }, + { IFP_PATH_USERS_TREE, &iface_ifp_users_user }, + { IFP_PATH_USERS_TREE, &iface_ifp_cache_object_user }, + { IFP_PATH_GROUPS, &iface_ifp_groups }, + { IFP_PATH_GROUPS, &iface_ifp_cache_group }, + { IFP_PATH_GROUPS_TREE, &iface_ifp_groups_group }, + { IFP_PATH_GROUPS_TREE, &iface_ifp_cache_object_group }, + {NULL, NULL} + }; + + ret = sbus_connection_add_path_map(conn, paths); + if (ret != EOK) { + DEBUG(SSSDBG_FATAL_FAILURE, "Unable to add paths [%d]: %s\n", + ret, sss_strerror(ret)); + } + + return ret; +} diff --git a/src/responder/ifp/ifp_iface/ifp_iface.h b/src/responder/ifp/ifp_iface/ifp_iface.h new file mode 100644 index 0000000..0bf6510 --- /dev/null +++ b/src/responder/ifp/ifp_iface/ifp_iface.h @@ -0,0 +1,40 @@ +/* + 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 _IFP_IFACE_H_ +#define _IFP_IFACE_H_ + +#define IFP_BUS "org.freedesktop.sssd.infopipe" + +#define IFP_PATH "/org/freedesktop/sssd/infopipe" + +#define IFP_PATH_DOMAINS IFP_PATH "/Domains" +#define IFP_PATH_DOMAINS_TREE IFP_PATH_DOMAINS "/*" + +#define IFP_PATH_COMPONENTS IFP_PATH "/Components" +#define IFP_PATH_COMPONENTS_TREE IFP_PATH_COMPONENTS "/*" + +#define IFP_PATH_GROUPS IFP_PATH "/Groups" +#define IFP_PATH_GROUPS_TREE IFP_PATH_GROUPS "/*" + +#define IFP_PATH_USERS IFP_PATH "/Users" +#define IFP_PATH_USERS_TREE IFP_PATH_USERS "/*" + +#endif /* _IFP_IFACE_H_ */ diff --git a/src/responder/ifp/ifp_iface/ifp_iface.xml b/src/responder/ifp/ifp_iface/ifp_iface.xml new file mode 100644 index 0000000..75b4891 --- /dev/null +++ b/src/responder/ifp/ifp_iface/ifp_iface.xml @@ -0,0 +1,253 @@ +<!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.sssd.infopipe"> + <annotation name="codegen.Name" value="ifp" /> + <annotation name="codegen.AsyncCaller" value="false" /> + + <method name="Ping"> + <arg name="ping" type="s" direction="in" key="1" /> + <arg name="pong" type="s" direction="out" /> + </method> + + <!-- SSSD components --> + + <method name="ListComponents" key="True"> + <arg name="components" type="ao" direction="out"/> + </method> + + <method name="ListResponders" key="True"> + <arg name="responders" type="ao" direction="out"/> + </method> + + <method name="ListBackends" key="True"> + <arg name="backends" type="ao" direction="out"/> + </method> + + <method name="FindMonitor" key="True"> + <arg name="monitor" type="o" direction="out"/> + </method> + + <method name="FindResponderByName"> + <arg name="name" type="s" direction="in" key="1" /> + <arg name="responder" type="o" direction="out"/> + </method> + + <method name="FindBackendByName"> + <arg name="name" type="s" direction="in" key="1" /> + <arg name="backend" type="o" direction="out"/> + </method> + + <method name="GetUserAttr"> + <annotation name="codegen.CustomOutputHandler" value="true"/> + <arg name="user" type="s" direction="in" /> + <arg name="attr" type="as" direction="in" /> + <arg name="values" type="a{sv}" direction="out"/> + </method> + + <method name="GetUserGroups"> + <arg name="user" type="s" direction="in" key="1" /> + <arg name="values" type="as" direction="out"/> + </method> + + <method name="FindDomainByName"> + <arg name="name" type="s" direction="in" key="1" /> + <arg name="domain" type="o" direction="out"/> + </method> + + <method name="ListDomains" key="True"> + <arg name="domain" type="ao" direction="out"/> + </method> + + </interface> + + <interface name="org.freedesktop.sssd.infopipe.Components"> + <annotation name="codegen.Name" value="ifp_components" /> + <annotation name="codegen.AsyncCaller" value="false" /> + + <property name="name" type="s" access="read" /> + <property name="debug_level" type="u" access="read" /> + <property name="enabled" type="b" access="read" /> + <property name="type" type="s" access="read" /> + + <!-- FIXME: This should be part of Components.Backends interface, onece + SSSD supports multiple interfaces per object path. --> + <property name="providers" type="as" access="read" /> + </interface> + + <interface name="org.freedesktop.sssd.infopipe.Domains"> + <annotation name="codegen.Name" value="ifp_domains" /> + <annotation name="codegen.AsyncCaller" value="false" /> + + <property name="name" type="s" access="read"/> + <property name="provider" type="s" access="read"/> + <property name="primary_servers" type="as" access="read"/> + <property name="backup_servers" type="as" access="read"/> + <property name="min_id" type="u" access="read"/> + <property name="max_id" type="u" access="read"/> + <property name="realm" type="s" access="read"/> + <property name="forest" type="s" access="read"/> + <property name="login_format" type="s" access="read"/> + <property name="fully_qualified_name_format" type="s" access="read"/> + <property name="enumerable" type="b" access="read"/> + <property name="use_fully_qualified_names" type="b" access="read"/> + <property name="subdomain" type="b" access="read"/> + <property name="parent_domain" type="o" access="read"/> + </interface> + + <interface name="org.freedesktop.sssd.infopipe.Domains.Domain"> + <annotation name="codegen.Name" value="ifp_domain" /> + <annotation name="codegen.AsyncCaller" value="false" /> + + <method name="IsOnline" key="True"> + <arg name="status" type="b" direction="out" /> + </method> + + <method name="ListServices" key="True"> + <arg name="services" type="as" direction="out" /> + </method> + + <method name="ActiveServer"> + <arg name="service" 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> + + <method name="RefreshAccessRules" key="True" /> + </interface> + + <interface name="org.freedesktop.sssd.infopipe.Cache"> + <annotation name="codegen.Name" value="ifp_cache" /> + <annotation name="codegen.AsyncCaller" value="false" /> + + <method name="List" key="True"> + <arg name="result" type="ao" direction="out" /> + </method> + <method name="ListByDomain"> + <arg name="domain_name" type="s" direction="in" key="1" /> + <arg name="result" type="ao" direction="out"/> + </method> + </interface> + + <interface name="org.freedesktop.sssd.infopipe.Cache.Object"> + <annotation name="codegen.Name" value="ifp_cache_object" /> + <annotation name="codegen.AsyncCaller" value="false" /> + + <method name="Store" key="True"> + <arg name="result" type="b" direction="out" /> + </method> + <method name="Remove" key="True"> + <arg name="result" type="b" direction="out" /> + </method> + </interface> + + <interface name="org.freedesktop.sssd.infopipe.Users"> + <annotation name="codegen.Name" value="ifp_users" /> + <annotation name="codegen.AsyncCaller" value="false" /> + + <method name="FindByName"> + <arg name="name" type="s" direction="in" key="1" /> + <arg name="result" type="o" direction="out" /> + </method> + <method name="FindByID"> + <arg name="id" type="u" direction="in" key="1" /> + <arg name="result" type="o" direction="out" /> + </method> + <method name="FindByCertificate"> + <arg name="pem_cert" type="s" direction="in" /> + <arg name="result" type="o" direction="out" /> + </method> + <method name="ListByCertificate"> + <arg name="pem_cert" type="s" direction="in" /> + <arg name="limit" type="u" direction="in" /> + <arg name="result" type="ao" direction="out" /> + </method> + <method name="FindByNameAndCertificate"> + <arg name="name" type="s" direction="in" /> + <arg name="pem_cert" type="s" direction="in" /> + <arg name="result" type="o" direction="out" /> + </method> + <method name="ListByName"> + <arg name="name_filter" type="s" direction="in" key="1" /> + <arg name="limit" type="u" direction="in" key="2" /> + <arg name="result" type="ao" direction="out" /> + </method> + <method name="ListByDomainAndName"> + <arg name="domain_name" type="s" direction="in" key="1" /> + <arg name="name_filter" type="s" direction="in" key="2" /> + <arg name="limit" type="u" direction="in" key="3" /> + <arg name="result" type="ao" direction="out"/> + </method> + <method name="FindByValidCertificate"> + <arg name="pem_cert" type="s" direction="in" /> + <arg name="result" type="o" direction="out" /> + </method> + <method name="ListByAttr"> + <arg name="attribute" type="s" direction="in" key="1" /> + <arg name="attr_filter" type="s" direction="in" key="2" /> + <arg name="limit" type="u" direction="in" key="3" /> + <arg name="result" type="ao" direction="out" /> + </method> + </interface> + + <interface name="org.freedesktop.sssd.infopipe.Users.User"> + <annotation name="codegen.Name" value="ifp_user" /> + <annotation name="codegen.AsyncCaller" value="false" /> + + <method name="UpdateGroupsList" key="True" /> + + <property name="name" type="s" access="read" /> + <property name="uidNumber" type="u" access="read" /> + <property name="gidNumber" type="u" access="read" /> + <property name="gecos" type="s" access="read" /> + <property name="homeDirectory" type="s" access="read" /> + <property name="loginShell" type="s" access="read" /> + <property name="uniqueID" type="s" access="read" /> + <property name="groups" type="ao" access="read" /> + <property name="domain" type="o" access="read" /> + <property name="domainname" type="s" access="read" /> + <property name="extraAttributes" type="ifp_extra" access="read" /> + </interface> + + <interface name="org.freedesktop.sssd.infopipe.Groups"> + <annotation name="codegen.Name" value="ifp_groups" /> + <annotation name="codegen.AsyncCaller" value="false" /> + + <method name="FindByName"> + <arg name="name" type="s" direction="in" key="1" /> + <arg name="result" type="o" direction="out" /> + </method> + <method name="FindByID"> + <arg name="id" type="u" direction="in" key="1" /> + <arg name="result" type="o" direction="out" /> + </method> + <method name="ListByName"> + <arg name="name_filter" type="s" direction="in" key="1" /> + <arg name="limit" type="u" direction="in" key="2" /> + <arg name="result" type="ao" direction="out" /> + </method> + <method name="ListByDomainAndName"> + <arg name="domain_name" type="s" direction="in" key="1" /> + <arg name="name_filter" type="s" direction="in" key="2" /> + <arg name="limit" type="u" direction="in" key="3" /> + <arg name="result" type="ao" direction="out"/> + </method> + </interface> + + <interface name="org.freedesktop.sssd.infopipe.Groups.Group"> + <annotation name="codegen.Name" value="ifp_group" /> + <annotation name="codegen.AsyncCaller" value="false" /> + + <method name="UpdateMemberList" key="True" /> + + <property name="name" type="s" access="read" /> + <property name="gidNumber" type="u" access="read" /> + <property name="uniqueID" type="s" access="read" /> + <property name="users" type="ao" access="read" /> + <property name="groups" type="ao" access="read" /> + </interface> +</node> diff --git a/src/responder/ifp/ifp_iface/ifp_iface_async.h b/src/responder/ifp/ifp_iface/ifp_iface_async.h new file mode 100644 index 0000000..bdf737d --- /dev/null +++ b/src/responder/ifp/ifp_iface/ifp_iface_async.h @@ -0,0 +1,28 @@ +/* + 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 _IFP_IFACE_ASYNC_H_ +#define _IFP_IFACE_ASYNC_H_ + +#include "responder/ifp/ifp_iface/sbus_ifp_server.h" +#include "responder/ifp/ifp_iface/sbus_ifp_client_async.h" +#include "responder/ifp/ifp_iface/ifp_iface.h" + +#endif /* _IFP_IFACE_ASYNC_H_ */ diff --git a/src/responder/ifp/ifp_iface/ifp_iface_sync.h b/src/responder/ifp/ifp_iface/ifp_iface_sync.h new file mode 100644 index 0000000..804e0dd --- /dev/null +++ b/src/responder/ifp/ifp_iface/ifp_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 _IFP_IFACE_SYNC_H_ +#define _IFP_IFACE_SYNC_H_ + +#include "responder/ifp/ifp_iface/sbus_ifp_client_sync.h" +#include "responder/ifp/ifp_iface/ifp_iface.h" + +#endif /* _IFP_IFACE_SYNC_H_ */ diff --git a/src/responder/ifp/ifp_iface/ifp_iface_types.c b/src/responder/ifp/ifp_iface/ifp_iface_types.c new file mode 100644 index 0000000..ad18304 --- /dev/null +++ b/src/responder/ifp/ifp_iface/ifp_iface_types.c @@ -0,0 +1,225 @@ +/* + 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 "responder/ifp/ifp_iface/ifp_iface_types.h" +#include "sbus/interface/sbus_iterator_readers.h" +#include "sbus/interface/sbus_iterator_writers.h" + +/** + * D-Bus signature: a{sas} + */ +errno_t sbus_iterator_read_ifp_extra(TALLOC_CTX *mem_ctx, + DBusMessageIter *iterator, + hash_table_t **_table) +{ + DBusMessageIter iter_array; + DBusMessageIter iter_dict; + hash_table_t *table; + hash_key_t hkey; + hash_value_t hvalue; + char **values; + char *key; + int arg_type; + errno_t ret; + int count; + int hret; + int i; + + ret = sss_hash_create(mem_ctx, 0, &table); + if (ret != EOK) { + return ret; + } + + arg_type = dbus_message_iter_get_arg_type(iterator); + if (arg_type != DBUS_TYPE_ARRAY) { + ret = ERR_SBUS_INVALID_TYPE; + goto done; + } + + count = dbus_message_iter_get_element_count(iterator); + dbus_message_iter_recurse(iterator, &iter_array); + + for (i = 0; i < count; i++) { + arg_type = dbus_message_iter_get_arg_type(&iter_array); + if (arg_type != DBUS_TYPE_DICT_ENTRY) { + ret = ERR_SBUS_INVALID_TYPE; + goto done; + } + + dbus_message_iter_recurse(&iter_array, &iter_dict); + + ret = sbus_iterator_read_S(table, &iter_dict, &key); + if (ret != EOK) { + goto done; + } + + ret = sbus_iterator_read_aS(table, &iter_dict, &values); + if (ret != EOK) { + goto done; + } + + hkey.type = HASH_KEY_STRING; + hkey.str = key; + + hvalue.type = HASH_VALUE_PTR; + hvalue.ptr = values; + + hret = hash_enter(table, &hkey, &hvalue); + if (hret != HASH_SUCCESS) { + ret = EIO; + goto done; + } + + /* dhash will duplicate the key internally */ + talloc_free(key); + + dbus_message_iter_next(&iter_array); + } + + *_table = table; + + ret = EOK; + +done: + if (ret != EOK) { + talloc_free(table); + } + + return ret; +} + +/** + * D-Bus signature: a{sas} + */ +errno_t sbus_iterator_write_ifp_extra(DBusMessageIter *iterator, + hash_table_t *table) +{ + DBusMessageIter it_array; + DBusMessageIter it_dict; + struct hash_iter_context_t *table_iter = NULL; + bool in_array = false; + bool in_dict = false; + hash_entry_t *entry; + const char **values; + dbus_bool_t dbret; + errno_t ret; + + dbret = dbus_message_iter_open_container(iterator, DBUS_TYPE_ARRAY, + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + DBUS_TYPE_STRING_AS_STRING + DBUS_TYPE_ARRAY_AS_STRING + DBUS_TYPE_STRING_AS_STRING + DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &it_array); + if (!dbret) { + ret = EIO; + goto done; + } + + in_array = true; + + if (table == NULL) { + dbret = dbus_message_iter_close_container(iterator, &it_array); + if (!dbret) { + ret = EIO; + goto done; + } + + in_array = false; + ret = EOK; + goto done; + } + + table_iter = new_hash_iter_context(table); + if (table_iter == NULL) { + DEBUG(SSSDBG_OP_FAILURE, "new_hash_iter_context failed.\n"); + ret = EINVAL; + goto done; + } + + while ((entry = table_iter->next(table_iter)) != NULL) { + if (entry->key.type != HASH_KEY_STRING || entry->key.str == NULL + || entry->value.type != HASH_VALUE_PTR + || entry->value.ptr == NULL) { + continue; + } + + dbret = dbus_message_iter_open_container(&it_array, + DBUS_TYPE_DICT_ENTRY, NULL, + &it_dict); + if (!dbret) { + ret = EIO; + goto done; + } + + in_dict = true; + + ret = sbus_iterator_write_s(&it_dict, entry->key.str); + if (ret != EOK) { + goto done; + } + + values = entry->value.ptr; + ret = sbus_iterator_write_as(&it_dict, values); + if (ret != EOK) { + goto done; + } + + dbret = dbus_message_iter_close_container(&it_array, &it_dict); + if (!dbret) { + ret = EIO; + goto done; + } + + in_dict = false; + } + + dbret = dbus_message_iter_close_container(iterator, &it_array); + if (!dbret) { + ret = EIO; + goto done; + } + + in_array = false; + ret = EOK; + +done: + if (ret != EOK) { + if (in_dict) { + dbus_message_iter_abandon_container(&it_array, &it_dict); + } + + if (in_array) { + dbus_message_iter_abandon_container(iterator, &it_array); + } + } + + if (table_iter != NULL) { + talloc_free(table_iter); + } + + return ret; +} diff --git a/src/responder/ifp/ifp_iface/ifp_iface_types.h b/src/responder/ifp/ifp_iface/ifp_iface_types.h new file mode 100644 index 0000000..0a3cbd0 --- /dev/null +++ b/src/responder/ifp/ifp_iface/ifp_iface_types.h @@ -0,0 +1,35 @@ +/* + 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 _IFP_IFACE_CUSTOM_TYPES_H_ +#define _IFP_IFACE_CUSTOM_TYPES_H_ + +#include <talloc.h> +#include <dhash.h> +#include <dbus/dbus.h> + +errno_t sbus_iterator_read_ifp_extra(TALLOC_CTX *mem_ctx, + DBusMessageIter *iterator, + hash_table_t **_table); + +errno_t sbus_iterator_write_ifp_extra(DBusMessageIter *iterator, + hash_table_t *table); + +#endif /* _IFP_IFACE_CUSTOM_TYPES_H_ */ diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_arguments.c b/src/responder/ifp/ifp_iface/sbus_ifp_arguments.c new file mode 100644 index 0000000..031db83 --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_arguments.c @@ -0,0 +1,397 @@ +/* + 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 "responder/ifp/ifp_iface/sbus_ifp_arguments.h" + +errno_t _sbus_ifp_invoker_read_ao + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ao *args) +{ + errno_t ret; + + ret = sbus_iterator_read_ao(mem_ctx, iter, &args->arg0); + if (ret != EOK) { + return ret; + } + + return EOK; +} + +errno_t _sbus_ifp_invoker_write_ao + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ao *args) +{ + errno_t ret; + + ret = sbus_iterator_write_ao(iter, args->arg0); + if (ret != EOK) { + return ret; + } + + return EOK; +} + +errno_t _sbus_ifp_invoker_read_as + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_write_as + (DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_read_b + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_write_b + (DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_read_ifp_extra + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ifp_extra *args) +{ + errno_t ret; + + ret = sbus_iterator_read_ifp_extra(mem_ctx, iter, &args->arg0); + if (ret != EOK) { + return ret; + } + + return EOK; +} + +errno_t _sbus_ifp_invoker_write_ifp_extra + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ifp_extra *args) +{ + errno_t ret; + + ret = sbus_iterator_write_ifp_extra(iter, args->arg0); + if (ret != EOK) { + return ret; + } + + return EOK; +} + +errno_t _sbus_ifp_invoker_read_o + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_write_o + (DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_read_s + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_write_s + (DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_read_sas + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_sas *args) +{ + errno_t ret; + + ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg0); + if (ret != EOK) { + return ret; + } + + ret = sbus_iterator_read_as(mem_ctx, iter, &args->arg1); + if (ret != EOK) { + return ret; + } + + return EOK; +} + +errno_t _sbus_ifp_invoker_write_sas + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_sas *args) +{ + errno_t ret; + + ret = sbus_iterator_write_s(iter, args->arg0); + if (ret != EOK) { + return ret; + } + + ret = sbus_iterator_write_as(iter, args->arg1); + if (ret != EOK) { + return ret; + } + + return EOK; +} + +errno_t _sbus_ifp_invoker_read_ss + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_write_ss + (DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_read_ssu + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ssu *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_u(iter, &args->arg2); + if (ret != EOK) { + return ret; + } + + return EOK; +} + +errno_t _sbus_ifp_invoker_write_ssu + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ssu *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_u(iter, args->arg2); + if (ret != EOK) { + return ret; + } + + return EOK; +} + +errno_t _sbus_ifp_invoker_read_su + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_su *args) +{ + errno_t ret; + + ret = sbus_iterator_read_s(mem_ctx, iter, &args->arg0); + if (ret != EOK) { + return ret; + } + + ret = sbus_iterator_read_u(iter, &args->arg1); + if (ret != EOK) { + return ret; + } + + return EOK; +} + +errno_t _sbus_ifp_invoker_write_su + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_su *args) +{ + errno_t ret; + + ret = sbus_iterator_write_s(iter, args->arg0); + if (ret != EOK) { + return ret; + } + + ret = sbus_iterator_write_u(iter, args->arg1); + if (ret != EOK) { + return ret; + } + + return EOK; +} + +errno_t _sbus_ifp_invoker_read_u + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_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_ifp_invoker_write_u + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_u *args) +{ + errno_t ret; + + ret = sbus_iterator_write_u(iter, args->arg0); + if (ret != EOK) { + return ret; + } + + return EOK; +} diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_arguments.h b/src/responder/ifp/ifp_iface/sbus_ifp_arguments.h new file mode 100644 index 0000000..4b88b78 --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_arguments.h @@ -0,0 +1,201 @@ +/* + 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_IFP_ARGUMENTS_H_ +#define _SBUS_IFP_ARGUMENTS_H_ + +#include <errno.h> +#include <stdint.h> +#include <talloc.h> +#include <stdbool.h> +#include <dbus/dbus.h> + +#include "responder/ifp/ifp_iface/ifp_iface_types.h" + +struct _sbus_ifp_invoker_args_ao { + const char ** arg0; +}; + +errno_t +_sbus_ifp_invoker_read_ao + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ao *args); + +errno_t +_sbus_ifp_invoker_write_ao + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ao *args); + +struct _sbus_ifp_invoker_args_as { + const char ** arg0; +}; + +errno_t +_sbus_ifp_invoker_read_as + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_as *args); + +errno_t +_sbus_ifp_invoker_write_as + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_as *args); + +struct _sbus_ifp_invoker_args_b { + bool arg0; +}; + +errno_t +_sbus_ifp_invoker_read_b + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_b *args); + +errno_t +_sbus_ifp_invoker_write_b + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_b *args); + +struct _sbus_ifp_invoker_args_ifp_extra { + hash_table_t * arg0; +}; + +errno_t +_sbus_ifp_invoker_read_ifp_extra + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ifp_extra *args); + +errno_t +_sbus_ifp_invoker_write_ifp_extra + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ifp_extra *args); + +struct _sbus_ifp_invoker_args_o { + const char * arg0; +}; + +errno_t +_sbus_ifp_invoker_read_o + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_o *args); + +errno_t +_sbus_ifp_invoker_write_o + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_o *args); + +struct _sbus_ifp_invoker_args_s { + const char * arg0; +}; + +errno_t +_sbus_ifp_invoker_read_s + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_s *args); + +errno_t +_sbus_ifp_invoker_write_s + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_s *args); + +struct _sbus_ifp_invoker_args_sas { + const char * arg0; + const char ** arg1; +}; + +errno_t +_sbus_ifp_invoker_read_sas + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_sas *args); + +errno_t +_sbus_ifp_invoker_write_sas + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_sas *args); + +struct _sbus_ifp_invoker_args_ss { + const char * arg0; + const char * arg1; +}; + +errno_t +_sbus_ifp_invoker_read_ss + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ss *args); + +errno_t +_sbus_ifp_invoker_write_ss + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ss *args); + +struct _sbus_ifp_invoker_args_ssu { + const char * arg0; + const char * arg1; + uint32_t arg2; +}; + +errno_t +_sbus_ifp_invoker_read_ssu + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ssu *args); + +errno_t +_sbus_ifp_invoker_write_ssu + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_ssu *args); + +struct _sbus_ifp_invoker_args_su { + const char * arg0; + uint32_t arg1; +}; + +errno_t +_sbus_ifp_invoker_read_su + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_su *args); + +errno_t +_sbus_ifp_invoker_write_su + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_su *args); + +struct _sbus_ifp_invoker_args_u { + uint32_t arg0; +}; + +errno_t +_sbus_ifp_invoker_read_u + (TALLOC_CTX *mem_ctx, + DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_u *args); + +errno_t +_sbus_ifp_invoker_write_u + (DBusMessageIter *iter, + struct _sbus_ifp_invoker_args_u *args); + +#endif /* _SBUS_IFP_ARGUMENTS_H_ */ diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_client_async.c b/src/responder/ifp/ifp_iface/sbus_ifp_client_async.c new file mode 100644 index 0000000..792061c --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_client_async.c @@ -0,0 +1,30 @@ +/* + 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 "responder/ifp/ifp_iface/sbus_ifp_arguments.h" +#include "responder/ifp/ifp_iface/sbus_ifp_keygens.h" +#include "responder/ifp/ifp_iface/sbus_ifp_client_properties.h" diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_client_async.h b/src/responder/ifp/ifp_iface/sbus_ifp_client_async.h new file mode 100644 index 0000000..eb7844b --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_client_async.h @@ -0,0 +1,31 @@ +/* + 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_IFP_CLIENT_ASYNC_H_ +#define _SBUS_IFP_CLIENT_ASYNC_H_ + +#include <errno.h> +#include <talloc.h> +#include <tevent.h> + +#include "sbus/sbus.h" +#include "responder/ifp/ifp_iface/sbus_ifp_client_properties.h" +#include "responder/ifp/ifp_iface/ifp_iface_types.h" + +#endif /* _SBUS_IFP_CLIENT_ASYNC_H_ */ diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_client_properties.h b/src/responder/ifp/ifp_iface/sbus_ifp_client_properties.h new file mode 100644 index 0000000..deb3ade --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_client_properties.h @@ -0,0 +1,180 @@ +/* + 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_IFP_CLIENT_PROPERTIES_H_ +#define _SBUS_IFP_CLIENT_PROPERTIES_H_ + +#include <stdint.h> +#include <stdbool.h> + +#include "responder/ifp/ifp_iface/ifp_iface_types.h" + +struct sbus_all_ifp_components { + struct { + bool is_set; + uint32_t value; + } debug_level; + struct { + bool is_set; + bool value; + } enabled; + struct { + bool is_set; + const char * value; + } name; + struct { + bool is_set; + const char ** value; + } providers; + struct { + bool is_set; + const char * value; + } type; +}; + +struct sbus_all_ifp_domains { + struct { + bool is_set; + const char ** value; + } backup_servers; + struct { + bool is_set; + bool value; + } enumerable; + struct { + bool is_set; + const char * value; + } forest; + struct { + bool is_set; + const char * value; + } fully_qualified_name_format; + struct { + bool is_set; + const char * value; + } login_format; + struct { + bool is_set; + uint32_t value; + } max_id; + struct { + bool is_set; + uint32_t value; + } min_id; + struct { + bool is_set; + const char * value; + } name; + struct { + bool is_set; + const char * value; + } parent_domain; + struct { + bool is_set; + const char ** value; + } primary_servers; + struct { + bool is_set; + const char * value; + } provider; + struct { + bool is_set; + const char * value; + } realm; + struct { + bool is_set; + bool value; + } subdomain; + struct { + bool is_set; + bool value; + } use_fully_qualified_names; +}; + +struct sbus_all_ifp_group { + struct { + bool is_set; + uint32_t value; + } gidNumber; + struct { + bool is_set; + const char ** value; + } groups; + struct { + bool is_set; + const char * value; + } name; + struct { + bool is_set; + const char * value; + } uniqueID; + struct { + bool is_set; + const char ** value; + } users; +}; + +struct sbus_all_ifp_user { + struct { + bool is_set; + const char * value; + } domain; + struct { + bool is_set; + const char * value; + } domainname; + struct { + bool is_set; + hash_table_t * value; + } extraAttributes; + struct { + bool is_set; + const char * value; + } gecos; + struct { + bool is_set; + uint32_t value; + } gidNumber; + struct { + bool is_set; + const char ** value; + } groups; + struct { + bool is_set; + const char * value; + } homeDirectory; + struct { + bool is_set; + const char * value; + } loginShell; + struct { + bool is_set; + const char * value; + } name; + struct { + bool is_set; + uint32_t value; + } uidNumber; + struct { + bool is_set; + const char * value; + } uniqueID; +}; + +#endif /* _SBUS_IFP_CLIENT_PROPERTIES_H_ */ diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_client_sync.c b/src/responder/ifp/ifp_iface/sbus_ifp_client_sync.c new file mode 100644 index 0000000..e450233 --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_client_sync.c @@ -0,0 +1,2304 @@ +/* + 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 "responder/ifp/ifp_iface/sbus_ifp_arguments.h" +#include "responder/ifp/ifp_iface/sbus_ifp_client_properties.h" + +static errno_t +sbus_method_in__out_ + (struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *method) +{ + TALLOC_CTX *tmp_ctx; + DBusMessage *reply; + errno_t ret; + + tmp_ctx = talloc_new(NULL); + if (tmp_ctx == NULL) { + DEBUG(SSSDBG_FATAL_FAILURE, "Out of memory!\n"); + return ENOMEM; + } + + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, NULL, + bus, path, iface, method, NULL, &reply); + if (ret != EOK) { + goto done; + } + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_method_in__out_ao + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *method, + const char *** _arg0) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_ao *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_ifp_invoker_args_ao); + if (out == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, + "Unable to allocate space for output parameters!\n"); + ret = ENOMEM; + goto done; + } + + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, NULL, + bus, path, iface, method, NULL, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_invoker_read_ao, out); + if (ret != EOK) { + goto done; + } + + *_arg0 = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_method_in__out_as + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *method, + const char *** _arg0) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_as *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_ifp_invoker_args_as); + if (out == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, + "Unable to allocate space for output parameters!\n"); + ret = ENOMEM; + goto done; + } + + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, NULL, + bus, path, iface, method, NULL, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_invoker_read_as, out); + if (ret != EOK) { + goto done; + } + + *_arg0 = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_method_in__out_b + (struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *method, + bool* _arg0) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_b *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_ifp_invoker_args_b); + if (out == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, + "Unable to allocate space for output parameters!\n"); + ret = ENOMEM; + goto done; + } + + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, NULL, + bus, path, iface, method, NULL, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_invoker_read_b, out); + if (ret != EOK) { + goto done; + } + + *_arg0 = out->arg0; + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_method_in__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) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_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_ifp_invoker_args_o); + if (out == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, + "Unable to allocate space for output parameters!\n"); + ret = ENOMEM; + goto done; + } + + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, NULL, + bus, path, iface, method, NULL, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_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; +} + +static errno_t +sbus_method_in_s_out_ao + (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 *** _arg0) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_s in; + struct _sbus_ifp_invoker_args_ao *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_ifp_invoker_args_ao); + if (out == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, + "Unable to allocate space for output parameters!\n"); + ret = ENOMEM; + goto done; + } + + in.arg0 = arg0; + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, + (sbus_invoker_writer_fn)_sbus_ifp_invoker_write_s, + bus, path, iface, method, &in, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_invoker_read_ao, out); + if (ret != EOK) { + goto done; + } + + *_arg0 = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_method_in_s_out_as + (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 *** _arg0) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_s in; + struct _sbus_ifp_invoker_args_as *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_ifp_invoker_args_as); + if (out == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, + "Unable to allocate space for output parameters!\n"); + ret = ENOMEM; + goto done; + } + + in.arg0 = arg0; + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, + (sbus_invoker_writer_fn)_sbus_ifp_invoker_write_s, + bus, path, iface, method, &in, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_invoker_read_as, out); + if (ret != EOK) { + goto done; + } + + *_arg0 = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_method_in_s_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 ** _arg0) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_s in; + struct _sbus_ifp_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_ifp_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; + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, + (sbus_invoker_writer_fn)_sbus_ifp_invoker_write_s, + bus, path, iface, method, &in, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_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; +} + +static errno_t +sbus_method_in_s_out_s + (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 ** _arg0) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_s in; + struct _sbus_ifp_invoker_args_s *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_ifp_invoker_args_s); + if (out == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, + "Unable to allocate space for output parameters!\n"); + ret = ENOMEM; + goto done; + } + + in.arg0 = arg0; + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, + (sbus_invoker_writer_fn)_sbus_ifp_invoker_write_s, + bus, path, iface, method, &in, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_invoker_read_s, out); + if (ret != EOK) { + goto done; + } + + *_arg0 = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_method_in_sas_out_raw + (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, + DBusMessage **_reply) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_sas in; + DBusMessage *reply; + errno_t ret; + + tmp_ctx = talloc_new(NULL); + if (tmp_ctx == NULL) { + DEBUG(SSSDBG_FATAL_FAILURE, "Out of memory!\n"); + return ENOMEM; + } + + in.arg0 = arg0; + in.arg1 = arg1; + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, + (sbus_invoker_writer_fn)_sbus_ifp_invoker_write_sas, + bus, path, iface, method, &in, &reply); + if (ret != EOK) { + goto done; + } + + /* Bounded reference cannot be unreferenced with dbus_message_unref. + * For that reason we do not allow NULL memory context as it would + * result in leaking the message memory. */ + if (mem_ctx == NULL) { + ret = EINVAL; + goto done; + } + + ret = sbus_message_bound_steal(mem_ctx, reply); + if (ret != EOK) { + DEBUG(SSSDBG_CRIT_FAILURE, "Unable to steal message [%d]: %s\n", + ret, sss_strerror(ret)); + goto done; + } + + *_reply = reply; + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +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_ifp_invoker_args_ss in; + struct _sbus_ifp_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_ifp_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_ifp_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_ifp_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; +} + +static errno_t +sbus_method_in_ssu_out_ao + (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, + uint32_t arg2, + const char *** _arg0) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_ssu in; + struct _sbus_ifp_invoker_args_ao *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_ifp_invoker_args_ao); + 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; + in.arg2 = arg2; + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, + (sbus_invoker_writer_fn)_sbus_ifp_invoker_write_ssu, + bus, path, iface, method, &in, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_invoker_read_ao, out); + if (ret != EOK) { + goto done; + } + + *_arg0 = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_method_in_su_out_ao + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *method, + const char * arg0, + uint32_t arg1, + const char *** _arg0) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_su in; + struct _sbus_ifp_invoker_args_ao *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_ifp_invoker_args_ao); + 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_ifp_invoker_write_su, + bus, path, iface, method, &in, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_invoker_read_ao, out); + if (ret != EOK) { + goto done; + } + + *_arg0 = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_method_in_u_out_o + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *method, + uint32_t arg0, + const char ** _arg0) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_u in; + struct _sbus_ifp_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_ifp_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; + + ret = sbus_sync_call_method(tmp_ctx, conn, NULL, + (sbus_invoker_writer_fn)_sbus_ifp_invoker_write_u, + bus, path, iface, method, &in, &reply); + if (ret != EOK) { + goto done; + } + + ret = sbus_read_output(out, reply, (sbus_invoker_reader_fn)_sbus_ifp_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_ifp_FindBackendByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char ** _arg_backend) +{ + return sbus_method_in_s_out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "FindBackendByName", arg_name, + _arg_backend); +} + +errno_t +sbus_call_ifp_FindDomainByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char ** _arg_domain) +{ + return sbus_method_in_s_out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "FindDomainByName", arg_name, + _arg_domain); +} + +errno_t +sbus_call_ifp_FindMonitor + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _arg_monitor) +{ + return sbus_method_in__out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "FindMonitor", + _arg_monitor); +} + +errno_t +sbus_call_ifp_FindResponderByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char ** _arg_responder) +{ + return sbus_method_in_s_out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "FindResponderByName", arg_name, + _arg_responder); +} + +errno_t +sbus_call_ifp_GetUserAttr + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_user, + const char ** arg_attr, + DBusMessage **_reply) +{ + return sbus_method_in_sas_out_raw(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "GetUserAttr", arg_user, arg_attr, + _reply); +} + +errno_t +sbus_call_ifp_GetUserGroups + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_user, + const char *** _arg_values) +{ + return sbus_method_in_s_out_as(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "GetUserGroups", arg_user, + _arg_values); +} + +errno_t +sbus_call_ifp_ListBackends + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_backends) +{ + return sbus_method_in__out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "ListBackends", + _arg_backends); +} + +errno_t +sbus_call_ifp_ListComponents + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_components) +{ + return sbus_method_in__out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "ListComponents", + _arg_components); +} + +errno_t +sbus_call_ifp_ListDomains + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_domain) +{ + return sbus_method_in__out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "ListDomains", + _arg_domain); +} + +errno_t +sbus_call_ifp_ListResponders + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_responders) +{ + return sbus_method_in__out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "ListResponders", + _arg_responders); +} + +errno_t +sbus_call_ifp_Ping + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_ping, + const char ** _arg_pong) +{ + return sbus_method_in_s_out_s(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe", "Ping", arg_ping, + _arg_pong); +} + +errno_t +sbus_call_ifp_cache_List + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_result) +{ + return sbus_method_in__out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Cache", "List", + _arg_result); +} + +errno_t +sbus_call_ifp_cache_ListByDomain + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_domain_name, + const char *** _arg_result) +{ + return sbus_method_in_s_out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Cache", "ListByDomain", arg_domain_name, + _arg_result); +} + +errno_t +sbus_call_ifp_cache_object_Remove + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _arg_result) +{ + return sbus_method_in__out_b(conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Cache.Object", "Remove", + _arg_result); +} + +errno_t +sbus_call_ifp_cache_object_Store + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _arg_result) +{ + return sbus_method_in__out_b(conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Cache.Object", "Store", + _arg_result); +} + +errno_t +sbus_call_ifp_domain_ActiveServer + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_service, + const char ** _arg_server) +{ + return sbus_method_in_s_out_s(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Domains.Domain", "ActiveServer", arg_service, + _arg_server); +} + +errno_t +sbus_call_ifp_domain_IsOnline + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _arg_status) +{ + return sbus_method_in__out_b(conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Domains.Domain", "IsOnline", + _arg_status); +} + +errno_t +sbus_call_ifp_domain_ListServers + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_service_name, + const char *** _arg_servers) +{ + return sbus_method_in_s_out_as(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Domains.Domain", "ListServers", arg_service_name, + _arg_servers); +} + +errno_t +sbus_call_ifp_domain_ListServices + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_services) +{ + return sbus_method_in__out_as(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Domains.Domain", "ListServices", + _arg_services); +} + +errno_t +sbus_call_ifp_domain_RefreshAccessRules + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path) +{ + return sbus_method_in__out_(conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Domains.Domain", "RefreshAccessRules"); +} + +errno_t +sbus_call_ifp_groups_FindByID + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t arg_id, + const char ** _arg_result) +{ + return sbus_method_in_u_out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Groups", "FindByID", arg_id, + _arg_result); +} + +errno_t +sbus_call_ifp_groups_FindByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char ** _arg_result) +{ + return sbus_method_in_s_out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Groups", "FindByName", arg_name, + _arg_result); +} + +errno_t +sbus_call_ifp_groups_ListByDomainAndName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_domain_name, + const char * arg_name_filter, + uint32_t arg_limit, + const char *** _arg_result) +{ + return sbus_method_in_ssu_out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Groups", "ListByDomainAndName", arg_domain_name, arg_name_filter, arg_limit, + _arg_result); +} + +errno_t +sbus_call_ifp_groups_ListByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name_filter, + uint32_t arg_limit, + const char *** _arg_result) +{ + return sbus_method_in_su_out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Groups", "ListByName", arg_name_filter, arg_limit, + _arg_result); +} + +errno_t +sbus_call_ifp_group_UpdateMemberList + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path) +{ + return sbus_method_in__out_(conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Groups.Group", "UpdateMemberList"); +} + +errno_t +sbus_call_ifp_users_FindByCertificate + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_pem_cert, + const char ** _arg_result) +{ + return sbus_method_in_s_out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users", "FindByCertificate", arg_pem_cert, + _arg_result); +} + +errno_t +sbus_call_ifp_users_FindByID + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t arg_id, + const char ** _arg_result) +{ + return sbus_method_in_u_out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users", "FindByID", arg_id, + _arg_result); +} + +errno_t +sbus_call_ifp_users_FindByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char ** _arg_result) +{ + return sbus_method_in_s_out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users", "FindByName", arg_name, + _arg_result); +} + +errno_t +sbus_call_ifp_users_FindByNameAndCertificate + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char * arg_pem_cert, + const char ** _arg_result) +{ + return sbus_method_in_ss_out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users", "FindByNameAndCertificate", arg_name, arg_pem_cert, + _arg_result); +} + +errno_t +sbus_call_ifp_users_FindByValidCertificate + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_pem_cert, + const char ** _arg_result) +{ + return sbus_method_in_s_out_o(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users", "FindByValidCertificate", arg_pem_cert, + _arg_result); +} + +errno_t +sbus_call_ifp_users_ListByAttr + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_attribute, + const char * arg_attr_filter, + uint32_t arg_limit, + const char *** _arg_result) +{ + return sbus_method_in_ssu_out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users", "ListByAttr", arg_attribute, arg_attr_filter, arg_limit, + _arg_result); +} + +errno_t +sbus_call_ifp_users_ListByCertificate + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_pem_cert, + uint32_t arg_limit, + const char *** _arg_result) +{ + return sbus_method_in_su_out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users", "ListByCertificate", arg_pem_cert, arg_limit, + _arg_result); +} + +errno_t +sbus_call_ifp_users_ListByDomainAndName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_domain_name, + const char * arg_name_filter, + uint32_t arg_limit, + const char *** _arg_result) +{ + return sbus_method_in_ssu_out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users", "ListByDomainAndName", arg_domain_name, arg_name_filter, arg_limit, + _arg_result); +} + +errno_t +sbus_call_ifp_users_ListByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name_filter, + uint32_t arg_limit, + const char *** _arg_result) +{ + return sbus_method_in_su_out_ao(mem_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users", "ListByName", arg_name_filter, arg_limit, + _arg_result); +} + +errno_t +sbus_call_ifp_user_UpdateGroupsList + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path) +{ + return sbus_method_in__out_(conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users.User", "UpdateGroupsList"); +} + +static errno_t +sbus_get_ao + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *property, + const char *** _value) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_ao *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_ifp_invoker_args_ao); + 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 = NULL; + reader_talloc = (sbus_value_reader_talloc_fn)sbus_iterator_read_ao; + ret = sbus_parse_get_message(out, reader, reader_talloc, reply, &out->arg0); + if (ret != EOK) { + goto done; + } + + *_value = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_get_as + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *property, + const char *** _value) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_as *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_ifp_invoker_args_as); + 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 = NULL; + reader_talloc = (sbus_value_reader_talloc_fn)sbus_iterator_read_as; + ret = sbus_parse_get_message(out, reader, reader_talloc, reply, &out->arg0); + if (ret != EOK) { + goto done; + } + + *_value = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_get_b + (struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *property, + bool* _value) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_b *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_ifp_invoker_args_b); + 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_b; + 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_get_ifp_extra + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *property, + hash_table_t ** _value) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_ifp_extra *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_ifp_invoker_args_ifp_extra); + 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 = NULL; + reader_talloc = (sbus_value_reader_talloc_fn)sbus_iterator_read_ifp_extra; + ret = sbus_parse_get_message(out, reader, reader_talloc, reply, &out->arg0); + if (ret != EOK) { + goto done; + } + + *_value = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_get_o + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *property, + const char ** _value) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_o *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_ifp_invoker_args_o); + 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 = NULL; + reader_talloc = (sbus_value_reader_talloc_fn)sbus_iterator_read_o; + ret = sbus_parse_get_message(out, reader, reader_talloc, reply, &out->arg0); + if (ret != EOK) { + goto done; + } + + *_value = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +static errno_t +sbus_get_s + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *bus, + const char *path, + const char *iface, + const char *property, + const char ** _value) +{ + TALLOC_CTX *tmp_ctx; + struct _sbus_ifp_invoker_args_s *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_ifp_invoker_args_s); + 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 = NULL; + reader_talloc = (sbus_value_reader_talloc_fn)sbus_iterator_read_s; + ret = sbus_parse_get_message(out, reader, reader_talloc, reply, &out->arg0); + if (ret != EOK) { + goto done; + } + + *_value = talloc_steal(mem_ctx, out->arg0); + + ret = EOK; + +done: + talloc_free(tmp_ctx); + + return ret; +} + +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_ifp_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_ifp_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; +} + +errno_t +sbus_get_ifp_components_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, + "org.freedesktop.sssd.infopipe.Components", "debug_level", _value); +} + +errno_t +sbus_get_ifp_components_enabled + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _value) +{ + return sbus_get_b(conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Components", "enabled", _value); +} + +errno_t +sbus_get_ifp_components_name + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Components", "name", _value); +} + +errno_t +sbus_get_ifp_components_providers + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value) +{ + return sbus_get_as(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Components", "providers", _value); +} + +errno_t +sbus_get_ifp_components_type + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Components", "type", _value); +} + +errno_t +sbus_get_ifp_domains_backup_servers + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value) +{ + return sbus_get_as(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "backup_servers", _value); +} + +errno_t +sbus_get_ifp_domains_enumerable + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _value) +{ + return sbus_get_b(conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "enumerable", _value); +} + +errno_t +sbus_get_ifp_domains_forest + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "forest", _value); +} + +errno_t +sbus_get_ifp_domains_fully_qualified_name_format + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "fully_qualified_name_format", _value); +} + +errno_t +sbus_get_ifp_domains_login_format + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "login_format", _value); +} + +errno_t +sbus_get_ifp_domains_max_id + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value) +{ + return sbus_get_u(conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "max_id", _value); +} + +errno_t +sbus_get_ifp_domains_min_id + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value) +{ + return sbus_get_u(conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "min_id", _value); +} + +errno_t +sbus_get_ifp_domains_name + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "name", _value); +} + +errno_t +sbus_get_ifp_domains_parent_domain + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_o(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "parent_domain", _value); +} + +errno_t +sbus_get_ifp_domains_primary_servers + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value) +{ + return sbus_get_as(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "primary_servers", _value); +} + +errno_t +sbus_get_ifp_domains_provider + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "provider", _value); +} + +errno_t +sbus_get_ifp_domains_realm + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "realm", _value); +} + +errno_t +sbus_get_ifp_domains_subdomain + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _value) +{ + return sbus_get_b(conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "subdomain", _value); +} + +errno_t +sbus_get_ifp_domains_use_fully_qualified_names + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _value) +{ + return sbus_get_b(conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Domains", "use_fully_qualified_names", _value); +} + +errno_t +sbus_get_ifp_group_gidNumber + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value) +{ + return sbus_get_u(conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Groups.Group", "gidNumber", _value); +} + +errno_t +sbus_get_ifp_group_groups + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value) +{ + return sbus_get_ao(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Groups.Group", "groups", _value); +} + +errno_t +sbus_get_ifp_group_name + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Groups.Group", "name", _value); +} + +errno_t +sbus_get_ifp_group_uniqueID + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Groups.Group", "uniqueID", _value); +} + +errno_t +sbus_get_ifp_group_users + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value) +{ + return sbus_get_ao(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Groups.Group", "users", _value); +} + +errno_t +sbus_get_ifp_user_domain + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_o(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "domain", _value); +} + +errno_t +sbus_get_ifp_user_domainname + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "domainname", _value); +} + +errno_t +sbus_get_ifp_user_extraAttributes + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + hash_table_t ** _value) +{ + return sbus_get_ifp_extra(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "extraAttributes", _value); +} + +errno_t +sbus_get_ifp_user_gecos + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "gecos", _value); +} + +errno_t +sbus_get_ifp_user_gidNumber + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value) +{ + return sbus_get_u(conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "gidNumber", _value); +} + +errno_t +sbus_get_ifp_user_groups + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value) +{ + return sbus_get_ao(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "groups", _value); +} + +errno_t +sbus_get_ifp_user_homeDirectory + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "homeDirectory", _value); +} + +errno_t +sbus_get_ifp_user_loginShell + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "loginShell", _value); +} + +errno_t +sbus_get_ifp_user_name + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "name", _value); +} + +errno_t +sbus_get_ifp_user_uidNumber + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value) +{ + return sbus_get_u(conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "uidNumber", _value); +} + +errno_t +sbus_get_ifp_user_uniqueID + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value) +{ + return sbus_get_s(mem_ctx, conn, busname, object_path, + "org.freedesktop.sssd.infopipe.Users.User", "uniqueID", _value); +} + +errno_t +sbus_getall_ifp_components + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + struct sbus_all_ifp_components **_properties) +{ + TALLOC_CTX *tmp_ctx; + struct sbus_all_ifp_components *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_ifp_components); + 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}, + {"enabled", (sbus_value_reader_fn)sbus_iterator_read_b, NULL, + &properties->enabled.value, &properties->enabled.is_set}, + {"name", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->name.value, &properties->name.is_set}, + {"providers", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_as, + &properties->providers.value, &properties->providers.is_set}, + {"type", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->type.value, &properties->type.is_set}, + {NULL, NULL, NULL, NULL, NULL} + }; + + ret = sbus_call_DBusProperties_GetAll(tmp_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Components", &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; +} + +errno_t +sbus_getall_ifp_domains + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + struct sbus_all_ifp_domains **_properties) +{ + TALLOC_CTX *tmp_ctx; + struct sbus_all_ifp_domains *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_ifp_domains); + if (properties == NULL) { + ret = ENOMEM; + goto done; + } + + struct sbus_parse_getall_table table[] = { + {"enumerable", (sbus_value_reader_fn)sbus_iterator_read_b, NULL, + &properties->enumerable.value, &properties->enumerable.is_set}, + {"max_id", (sbus_value_reader_fn)sbus_iterator_read_u, NULL, + &properties->max_id.value, &properties->max_id.is_set}, + {"min_id", (sbus_value_reader_fn)sbus_iterator_read_u, NULL, + &properties->min_id.value, &properties->min_id.is_set}, + {"subdomain", (sbus_value_reader_fn)sbus_iterator_read_b, NULL, + &properties->subdomain.value, &properties->subdomain.is_set}, + {"use_fully_qualified_names", (sbus_value_reader_fn)sbus_iterator_read_b, NULL, + &properties->use_fully_qualified_names.value, &properties->use_fully_qualified_names.is_set}, + {"backup_servers", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_as, + &properties->backup_servers.value, &properties->backup_servers.is_set}, + {"forest", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->forest.value, &properties->forest.is_set}, + {"fully_qualified_name_format", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->fully_qualified_name_format.value, &properties->fully_qualified_name_format.is_set}, + {"login_format", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->login_format.value, &properties->login_format.is_set}, + {"name", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->name.value, &properties->name.is_set}, + {"parent_domain", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_o, + &properties->parent_domain.value, &properties->parent_domain.is_set}, + {"primary_servers", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_as, + &properties->primary_servers.value, &properties->primary_servers.is_set}, + {"provider", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->provider.value, &properties->provider.is_set}, + {"realm", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->realm.value, &properties->realm.is_set}, + {NULL, NULL, NULL, NULL, NULL} + }; + + ret = sbus_call_DBusProperties_GetAll(tmp_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Domains", &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; +} + +errno_t +sbus_getall_ifp_group + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + struct sbus_all_ifp_group **_properties) +{ + TALLOC_CTX *tmp_ctx; + struct sbus_all_ifp_group *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_ifp_group); + if (properties == NULL) { + ret = ENOMEM; + goto done; + } + + struct sbus_parse_getall_table table[] = { + {"gidNumber", (sbus_value_reader_fn)sbus_iterator_read_u, NULL, + &properties->gidNumber.value, &properties->gidNumber.is_set}, + {"groups", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_ao, + &properties->groups.value, &properties->groups.is_set}, + {"name", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->name.value, &properties->name.is_set}, + {"uniqueID", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->uniqueID.value, &properties->uniqueID.is_set}, + {"users", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_ao, + &properties->users.value, &properties->users.is_set}, + {NULL, NULL, NULL, NULL, NULL} + }; + + ret = sbus_call_DBusProperties_GetAll(tmp_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Groups.Group", &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; +} + +errno_t +sbus_getall_ifp_user + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + struct sbus_all_ifp_user **_properties) +{ + TALLOC_CTX *tmp_ctx; + struct sbus_all_ifp_user *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_ifp_user); + if (properties == NULL) { + ret = ENOMEM; + goto done; + } + + struct sbus_parse_getall_table table[] = { + {"gidNumber", (sbus_value_reader_fn)sbus_iterator_read_u, NULL, + &properties->gidNumber.value, &properties->gidNumber.is_set}, + {"uidNumber", (sbus_value_reader_fn)sbus_iterator_read_u, NULL, + &properties->uidNumber.value, &properties->uidNumber.is_set}, + {"domain", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_o, + &properties->domain.value, &properties->domain.is_set}, + {"domainname", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->domainname.value, &properties->domainname.is_set}, + {"extraAttributes", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_ifp_extra, + &properties->extraAttributes.value, &properties->extraAttributes.is_set}, + {"gecos", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->gecos.value, &properties->gecos.is_set}, + {"groups", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_ao, + &properties->groups.value, &properties->groups.is_set}, + {"homeDirectory", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->homeDirectory.value, &properties->homeDirectory.is_set}, + {"loginShell", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->loginShell.value, &properties->loginShell.is_set}, + {"name", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->name.value, &properties->name.is_set}, + {"uniqueID", NULL, (sbus_value_reader_talloc_fn)sbus_iterator_read_s, + &properties->uniqueID.value, &properties->uniqueID.is_set}, + {NULL, NULL, NULL, NULL, NULL} + }; + + ret = sbus_call_DBusProperties_GetAll(tmp_ctx, conn, + busname, object_path, "org.freedesktop.sssd.infopipe.Users.User", &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/responder/ifp/ifp_iface/sbus_ifp_client_sync.h b/src/responder/ifp/ifp_iface/sbus_ifp_client_sync.h new file mode 100644 index 0000000..b5455e9 --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_client_sync.h @@ -0,0 +1,637 @@ +/* + 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_IFP_CLIENT_SYNC_H_ +#define _SBUS_IFP_CLIENT_SYNC_H_ + +#include <errno.h> +#include <talloc.h> +#include <tevent.h> + +#include "sbus/sbus_sync.h" +#include "responder/ifp/ifp_iface/sbus_ifp_client_properties.h" +#include "responder/ifp/ifp_iface/ifp_iface_types.h" + +errno_t +sbus_call_ifp_FindBackendByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char ** _arg_backend); + +errno_t +sbus_call_ifp_FindDomainByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char ** _arg_domain); + +errno_t +sbus_call_ifp_FindMonitor + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _arg_monitor); + +errno_t +sbus_call_ifp_FindResponderByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char ** _arg_responder); + +errno_t +sbus_call_ifp_GetUserAttr + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_user, + const char ** arg_attr, + DBusMessage **_reply); + +errno_t +sbus_call_ifp_GetUserGroups + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_user, + const char *** _arg_values); + +errno_t +sbus_call_ifp_ListBackends + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_backends); + +errno_t +sbus_call_ifp_ListComponents + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_components); + +errno_t +sbus_call_ifp_ListDomains + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_domain); + +errno_t +sbus_call_ifp_ListResponders + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_responders); + +errno_t +sbus_call_ifp_Ping + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_ping, + const char ** _arg_pong); + +errno_t +sbus_call_ifp_cache_List + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_result); + +errno_t +sbus_call_ifp_cache_ListByDomain + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_domain_name, + const char *** _arg_result); + +errno_t +sbus_call_ifp_cache_object_Remove + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _arg_result); + +errno_t +sbus_call_ifp_cache_object_Store + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _arg_result); + +errno_t +sbus_call_ifp_domain_ActiveServer + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_service, + const char ** _arg_server); + +errno_t +sbus_call_ifp_domain_IsOnline + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _arg_status); + +errno_t +sbus_call_ifp_domain_ListServers + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_service_name, + const char *** _arg_servers); + +errno_t +sbus_call_ifp_domain_ListServices + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _arg_services); + +errno_t +sbus_call_ifp_domain_RefreshAccessRules + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path); + +errno_t +sbus_call_ifp_groups_FindByID + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t arg_id, + const char ** _arg_result); + +errno_t +sbus_call_ifp_groups_FindByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char ** _arg_result); + +errno_t +sbus_call_ifp_groups_ListByDomainAndName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_domain_name, + const char * arg_name_filter, + uint32_t arg_limit, + const char *** _arg_result); + +errno_t +sbus_call_ifp_groups_ListByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name_filter, + uint32_t arg_limit, + const char *** _arg_result); + +errno_t +sbus_call_ifp_group_UpdateMemberList + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path); + +errno_t +sbus_call_ifp_users_FindByCertificate + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_pem_cert, + const char ** _arg_result); + +errno_t +sbus_call_ifp_users_FindByID + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t arg_id, + const char ** _arg_result); + +errno_t +sbus_call_ifp_users_FindByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char ** _arg_result); + +errno_t +sbus_call_ifp_users_FindByNameAndCertificate + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name, + const char * arg_pem_cert, + const char ** _arg_result); + +errno_t +sbus_call_ifp_users_FindByValidCertificate + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_pem_cert, + const char ** _arg_result); + +errno_t +sbus_call_ifp_users_ListByAttr + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_attribute, + const char * arg_attr_filter, + uint32_t arg_limit, + const char *** _arg_result); + +errno_t +sbus_call_ifp_users_ListByCertificate + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_pem_cert, + uint32_t arg_limit, + const char *** _arg_result); + +errno_t +sbus_call_ifp_users_ListByDomainAndName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_domain_name, + const char * arg_name_filter, + uint32_t arg_limit, + const char *** _arg_result); + +errno_t +sbus_call_ifp_users_ListByName + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char * arg_name_filter, + uint32_t arg_limit, + const char *** _arg_result); + +errno_t +sbus_call_ifp_user_UpdateGroupsList + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path); + +errno_t +sbus_get_ifp_components_debug_level + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value); + +errno_t +sbus_get_ifp_components_enabled + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _value); + +errno_t +sbus_get_ifp_components_name + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_components_providers + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value); + +errno_t +sbus_get_ifp_components_type + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_domains_backup_servers + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value); + +errno_t +sbus_get_ifp_domains_enumerable + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _value); + +errno_t +sbus_get_ifp_domains_forest + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_domains_fully_qualified_name_format + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_domains_login_format + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_domains_max_id + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value); + +errno_t +sbus_get_ifp_domains_min_id + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value); + +errno_t +sbus_get_ifp_domains_name + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_domains_parent_domain + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_domains_primary_servers + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value); + +errno_t +sbus_get_ifp_domains_provider + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_domains_realm + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_domains_subdomain + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _value); + +errno_t +sbus_get_ifp_domains_use_fully_qualified_names + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + bool* _value); + +errno_t +sbus_get_ifp_group_gidNumber + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value); + +errno_t +sbus_get_ifp_group_groups + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value); + +errno_t +sbus_get_ifp_group_name + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_group_uniqueID + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_group_users + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value); + +errno_t +sbus_get_ifp_user_domain + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_user_domainname + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_user_extraAttributes + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + hash_table_t ** _value); + +errno_t +sbus_get_ifp_user_gecos + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_user_gidNumber + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value); + +errno_t +sbus_get_ifp_user_groups + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char *** _value); + +errno_t +sbus_get_ifp_user_homeDirectory + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_user_loginShell + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_user_name + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_get_ifp_user_uidNumber + (struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + uint32_t* _value); + +errno_t +sbus_get_ifp_user_uniqueID + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + const char ** _value); + +errno_t +sbus_getall_ifp_components + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + struct sbus_all_ifp_components **_properties); + +errno_t +sbus_getall_ifp_domains + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + struct sbus_all_ifp_domains **_properties); + +errno_t +sbus_getall_ifp_group + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + struct sbus_all_ifp_group **_properties); + +errno_t +sbus_getall_ifp_user + (TALLOC_CTX *mem_ctx, + struct sbus_sync_connection *conn, + const char *busname, + const char *object_path, + struct sbus_all_ifp_user **_properties); + +#endif /* _SBUS_IFP_CLIENT_SYNC_H_ */ diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_interface.h b/src/responder/ifp/ifp_iface/sbus_ifp_interface.h new file mode 100644 index 0000000..0faac69 --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_interface.h @@ -0,0 +1,2083 @@ +/* + 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_IFP_INTERFACE_H_ +#define _SBUS_IFP_INTERFACE_H_ + +#include "sbus/sbus_interface_declarations.h" +#include "responder/ifp/ifp_iface/sbus_ifp_invokers.h" +#include "responder/ifp/ifp_iface/sbus_ifp_symbols.h" +#include "responder/ifp/ifp_iface/sbus_ifp_keygens.h" + +/* Interface: org.freedesktop.sssd.infopipe */ +#define SBUS_IFACE_org_freedesktop_sssd_infopipe(methods, signals, properties) ({ \ + sbus_interface("org.freedesktop.sssd.infopipe", NULL, \ + (methods), (signals), (properties)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.FindBackendByName */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_FindBackendByName(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \ + sbus_method_sync("FindBackendByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindBackendByName, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + _sbus_ifp_key_s_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_FindBackendByName(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("FindBackendByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindBackendByName, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + _sbus_ifp_key_s_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.FindDomainByName */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_FindDomainByName(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \ + sbus_method_sync("FindDomainByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindDomainByName, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + _sbus_ifp_key_s_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_FindDomainByName(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("FindDomainByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindDomainByName, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + _sbus_ifp_key_s_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.FindMonitor */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_FindMonitor(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_method_sync("FindMonitor", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindMonitor, \ + NULL, \ + _sbus_ifp_invoke_in__out_o_send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_FindMonitor(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("FindMonitor", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindMonitor, \ + NULL, \ + _sbus_ifp_invoke_in__out_o_send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.FindResponderByName */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_FindResponderByName(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \ + sbus_method_sync("FindResponderByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindResponderByName, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + _sbus_ifp_key_s_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_FindResponderByName(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("FindResponderByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindResponderByName, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + _sbus_ifp_key_s_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.GetUserAttr */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_GetUserAttr(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char **, DBusMessageIter *); \ + sbus_method_sync("GetUserAttr", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_GetUserAttr, \ + NULL, \ + _sbus_ifp_invoke_in_sas_out_raw_send, \ + NULL, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_GetUserAttr(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *, const char **, DBusMessageIter *); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_method_async("GetUserAttr", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_GetUserAttr, \ + NULL, \ + _sbus_ifp_invoke_in_sas_out_raw_send, \ + NULL, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.GetUserGroups */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_GetUserGroups(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char ***); \ + sbus_method_sync("GetUserGroups", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_GetUserGroups, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_as_send, \ + _sbus_ifp_key_s_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_GetUserGroups(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("GetUserGroups", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_GetUserGroups, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_as_send, \ + _sbus_ifp_key_s_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.ListBackends */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_ListBackends(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_method_sync("ListBackends", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListBackends, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_ListBackends(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListBackends", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListBackends, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.ListComponents */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_ListComponents(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_method_sync("ListComponents", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListComponents, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_ListComponents(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListComponents", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListComponents, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.ListDomains */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_ListDomains(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_method_sync("ListDomains", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListDomains, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_ListDomains(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListDomains", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListDomains, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.ListResponders */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_ListResponders(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_method_sync("ListResponders", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListResponders, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_ListResponders(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListResponders", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListResponders, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Ping */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Ping(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \ + sbus_method_sync("Ping", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Ping, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_s_send, \ + _sbus_ifp_key_s_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Ping(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("Ping", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Ping, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_s_send, \ + _sbus_ifp_key_s_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Interface: org.freedesktop.sssd.infopipe.Cache */ +#define SBUS_IFACE_org_freedesktop_sssd_infopipe_Cache(methods, signals, properties) ({ \ + sbus_interface("org.freedesktop.sssd.infopipe.Cache", NULL, \ + (methods), (signals), (properties)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Cache.List */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Cache_List(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_method_sync("List", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_List, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Cache_List(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("List", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_List, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Cache.ListByDomain */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Cache_ListByDomain(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char ***); \ + sbus_method_sync("ListByDomain", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_ListByDomain, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_ao_send, \ + _sbus_ifp_key_s_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Cache_ListByDomain(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListByDomain", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_ListByDomain, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_ao_send, \ + _sbus_ifp_key_s_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Interface: org.freedesktop.sssd.infopipe.Cache.Object */ +#define SBUS_IFACE_org_freedesktop_sssd_infopipe_Cache_Object(methods, signals, properties) ({ \ + sbus_interface("org.freedesktop.sssd.infopipe.Cache.Object", NULL, \ + (methods), (signals), (properties)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Cache.Object.Remove */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Cache_Object_Remove(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), bool*); \ + sbus_method_sync("Remove", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_Object_Remove, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Cache_Object_Remove(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), bool*); \ + sbus_method_async("Remove", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_Object_Remove, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Cache.Object.Store */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Cache_Object_Store(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), bool*); \ + sbus_method_sync("Store", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_Object_Store, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Cache_Object_Store(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), bool*); \ + sbus_method_async("Store", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_Object_Store, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Interface: org.freedesktop.sssd.infopipe.Components */ +#define SBUS_IFACE_org_freedesktop_sssd_infopipe_Components(methods, signals, properties) ({ \ + sbus_interface("org.freedesktop.sssd.infopipe.Components", NULL, \ + (methods), (signals), (properties)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Components.debug_level */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Components_debug_level(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), uint32_t*); \ + sbus_property_sync("debug_level", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Components_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_ifp_invoke_in__out_u_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Components_debug_level(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("debug_level", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Components_debug_level(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("debug_level", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Components.enabled */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Components_enabled(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), bool*); \ + sbus_property_sync("enabled", "b", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Components_enabled(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), bool*); \ + sbus_property_async("enabled", "b", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Components_enabled(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("enabled", "b", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Components_enabled(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("enabled", "b", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Components.name */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Components_name(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("name", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Components_name(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("name", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Components_name(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("name", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Components_name(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("name", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Components.providers */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Components_providers(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_property_sync("providers", "as", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_as_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Components_providers(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_property_async("providers", "as", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_as_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Components_providers(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("providers", "as", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Components_providers(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("providers", "as", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Components.type */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Components_type(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("type", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Components_type(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("type", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Components_type(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("type", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Components_type(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("type", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Interface: org.freedesktop.sssd.infopipe.Domains */ +#define SBUS_IFACE_org_freedesktop_sssd_infopipe_Domains(methods, signals, properties) ({ \ + sbus_interface("org.freedesktop.sssd.infopipe.Domains", NULL, \ + (methods), (signals), (properties)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.backup_servers */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_backup_servers(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_property_sync("backup_servers", "as", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_as_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_backup_servers(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_property_async("backup_servers", "as", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_as_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_backup_servers(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("backup_servers", "as", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_backup_servers(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("backup_servers", "as", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.enumerable */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_enumerable(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), bool*); \ + sbus_property_sync("enumerable", "b", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_enumerable(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), bool*); \ + sbus_property_async("enumerable", "b", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_enumerable(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("enumerable", "b", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_enumerable(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("enumerable", "b", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.forest */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_forest(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("forest", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_forest(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("forest", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_forest(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("forest", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_forest(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("forest", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.fully_qualified_name_format */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_fully_qualified_name_format(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("fully_qualified_name_format", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_fully_qualified_name_format(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("fully_qualified_name_format", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_fully_qualified_name_format(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("fully_qualified_name_format", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_fully_qualified_name_format(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("fully_qualified_name_format", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.login_format */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_login_format(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("login_format", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_login_format(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("login_format", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_login_format(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("login_format", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_login_format(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("login_format", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.max_id */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_max_id(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), uint32_t*); \ + sbus_property_sync("max_id", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_max_id(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), uint32_t*); \ + sbus_property_async("max_id", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_max_id(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("max_id", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_max_id(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("max_id", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.min_id */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_min_id(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), uint32_t*); \ + sbus_property_sync("min_id", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_min_id(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), uint32_t*); \ + sbus_property_async("min_id", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_min_id(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("min_id", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_min_id(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("min_id", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.name */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_name(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("name", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_name(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("name", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_name(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("name", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_name(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("name", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.parent_domain */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_parent_domain(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("parent_domain", "o", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_o_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_parent_domain(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("parent_domain", "o", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_o_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_parent_domain(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("parent_domain", "o", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_parent_domain(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("parent_domain", "o", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.primary_servers */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_primary_servers(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_property_sync("primary_servers", "as", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_as_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_primary_servers(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_property_async("primary_servers", "as", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_as_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_primary_servers(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("primary_servers", "as", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_primary_servers(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("primary_servers", "as", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.provider */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_provider(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("provider", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_provider(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("provider", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_provider(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("provider", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_provider(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("provider", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.realm */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_realm(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("realm", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_realm(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("realm", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_realm(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("realm", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_realm(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("realm", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.subdomain */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_subdomain(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), bool*); \ + sbus_property_sync("subdomain", "b", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_subdomain(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), bool*); \ + sbus_property_async("subdomain", "b", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_subdomain(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("subdomain", "b", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_subdomain(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("subdomain", "b", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Domains.use_fully_qualified_names */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_use_fully_qualified_names(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), bool*); \ + sbus_property_sync("use_fully_qualified_names", "b", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_use_fully_qualified_names(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), bool*); \ + sbus_property_async("use_fully_qualified_names", "b", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Domains_use_fully_qualified_names(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("use_fully_qualified_names", "b", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Domains_use_fully_qualified_names(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("use_fully_qualified_names", "b", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Interface: org.freedesktop.sssd.infopipe.Domains.Domain */ +#define SBUS_IFACE_org_freedesktop_sssd_infopipe_Domains_Domain(methods, signals, properties) ({ \ + sbus_interface("org.freedesktop.sssd.infopipe.Domains.Domain", NULL, \ + (methods), (signals), (properties)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Domains.Domain.ActiveServer */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Domains_Domain_ActiveServer(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \ + sbus_method_sync("ActiveServer", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ActiveServer, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_s_send, \ + _sbus_ifp_key_s_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Domains_Domain_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_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ActiveServer, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_s_send, \ + _sbus_ifp_key_s_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Domains.Domain.IsOnline */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Domains_Domain_IsOnline(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), bool*); \ + sbus_method_sync("IsOnline", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_IsOnline, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Domains_Domain_IsOnline(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), bool*); \ + sbus_method_async("IsOnline", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_IsOnline, \ + NULL, \ + _sbus_ifp_invoke_in__out_b_send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Domains.Domain.ListServers */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Domains_Domain_ListServers(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char ***); \ + sbus_method_sync("ListServers", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ListServers, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_as_send, \ + _sbus_ifp_key_s_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Domains_Domain_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_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ListServers, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_as_send, \ + _sbus_ifp_key_s_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Domains.Domain.ListServices */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Domains_Domain_ListServices(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_method_sync("ListServices", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ListServices, \ + NULL, \ + _sbus_ifp_invoke_in__out_as_send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Domains_Domain_ListServices(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListServices", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ListServices, \ + NULL, \ + _sbus_ifp_invoke_in__out_as_send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Domains.Domain.RefreshAccessRules */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Domains_Domain_RefreshAccessRules(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_method_sync("RefreshAccessRules", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_RefreshAccessRules, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Domains_Domain_RefreshAccessRules(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_method_async("RefreshAccessRules", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_RefreshAccessRules, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Interface: org.freedesktop.sssd.infopipe.Groups */ +#define SBUS_IFACE_org_freedesktop_sssd_infopipe_Groups(methods, signals, properties) ({ \ + sbus_interface("org.freedesktop.sssd.infopipe.Groups", NULL, \ + (methods), (signals), (properties)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Groups.FindByID */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Groups_FindByID(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), uint32_t, const char **); \ + sbus_method_sync("FindByID", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_FindByID, \ + NULL, \ + _sbus_ifp_invoke_in_u_out_o_send, \ + _sbus_ifp_key_u_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Groups_FindByID(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), uint32_t); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("FindByID", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_FindByID, \ + NULL, \ + _sbus_ifp_invoke_in_u_out_o_send, \ + _sbus_ifp_key_u_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Groups.FindByName */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Groups_FindByName(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \ + sbus_method_sync("FindByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_FindByName, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + _sbus_ifp_key_s_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Groups_FindByName(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("FindByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_FindByName, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + _sbus_ifp_key_s_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Groups.ListByDomainAndName */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Groups_ListByDomainAndName(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char *, uint32_t, const char ***); \ + sbus_method_sync("ListByDomainAndName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_ListByDomainAndName, \ + NULL, \ + _sbus_ifp_invoke_in_ssu_out_ao_send, \ + _sbus_ifp_key_ssu_0_1_2, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Groups_ListByDomainAndName(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *, const char *, uint32_t); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListByDomainAndName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_ListByDomainAndName, \ + NULL, \ + _sbus_ifp_invoke_in_ssu_out_ao_send, \ + _sbus_ifp_key_ssu_0_1_2, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Groups.ListByName */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Groups_ListByName(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, uint32_t, const char ***); \ + sbus_method_sync("ListByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_ListByName, \ + NULL, \ + _sbus_ifp_invoke_in_su_out_ao_send, \ + _sbus_ifp_key_su_0_1, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Groups_ListByName(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *, uint32_t); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_ListByName, \ + NULL, \ + _sbus_ifp_invoke_in_su_out_ao_send, \ + _sbus_ifp_key_su_0_1, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Interface: org.freedesktop.sssd.infopipe.Groups.Group */ +#define SBUS_IFACE_org_freedesktop_sssd_infopipe_Groups_Group(methods, signals, properties) ({ \ + sbus_interface("org.freedesktop.sssd.infopipe.Groups.Group", NULL, \ + (methods), (signals), (properties)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Groups.Group.UpdateMemberList */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_UpdateMemberList(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_method_sync("UpdateMemberList", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_Group_UpdateMemberList, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_UpdateMemberList(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_method_async("UpdateMemberList", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_Group_UpdateMemberList, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Groups.Group.gidNumber */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_gidNumber(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), uint32_t*); \ + sbus_property_sync("gidNumber", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_gidNumber(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), uint32_t*); \ + sbus_property_async("gidNumber", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_gidNumber(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("gidNumber", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_gidNumber(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("gidNumber", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Groups.Group.groups */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_groups(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_property_sync("groups", "ao", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_groups(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_property_async("groups", "ao", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_groups(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("groups", "ao", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_groups(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("groups", "ao", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Groups.Group.name */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_name(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("name", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_name(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("name", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_name(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("name", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_name(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("name", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Groups.Group.uniqueID */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_uniqueID(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("uniqueID", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_uniqueID(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("uniqueID", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_uniqueID(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("uniqueID", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_uniqueID(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("uniqueID", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Groups.Group.users */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_users(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_property_sync("users", "ao", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_users(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_property_async("users", "ao", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Groups_Group_users(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("users", "ao", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Groups_Group_users(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("users", "ao", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Interface: org.freedesktop.sssd.infopipe.Users */ +#define SBUS_IFACE_org_freedesktop_sssd_infopipe_Users(methods, signals, properties) ({ \ + sbus_interface("org.freedesktop.sssd.infopipe.Users", NULL, \ + (methods), (signals), (properties)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Users.FindByCertificate */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Users_FindByCertificate(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \ + sbus_method_sync("FindByCertificate", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByCertificate, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + NULL, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Users_FindByCertificate(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("FindByCertificate", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByCertificate, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + NULL, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Users.FindByID */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Users_FindByID(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), uint32_t, const char **); \ + sbus_method_sync("FindByID", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByID, \ + NULL, \ + _sbus_ifp_invoke_in_u_out_o_send, \ + _sbus_ifp_key_u_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Users_FindByID(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), uint32_t); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("FindByID", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByID, \ + NULL, \ + _sbus_ifp_invoke_in_u_out_o_send, \ + _sbus_ifp_key_u_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Users.FindByName */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Users_FindByName(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \ + sbus_method_sync("FindByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByName, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + _sbus_ifp_key_s_0, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Users_FindByName(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("FindByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByName, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + _sbus_ifp_key_s_0, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Users.FindByNameAndCertificate */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Users_FindByNameAndCertificate(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char *, const char **); \ + sbus_method_sync("FindByNameAndCertificate", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByNameAndCertificate, \ + NULL, \ + _sbus_ifp_invoke_in_ss_out_o_send, \ + NULL, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Users_FindByNameAndCertificate(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("FindByNameAndCertificate", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByNameAndCertificate, \ + NULL, \ + _sbus_ifp_invoke_in_ss_out_o_send, \ + NULL, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Users.FindByValidCertificate */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Users_FindByValidCertificate(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \ + sbus_method_sync("FindByValidCertificate", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByValidCertificate, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + NULL, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Users_FindByValidCertificate(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_method_async("FindByValidCertificate", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByValidCertificate, \ + NULL, \ + _sbus_ifp_invoke_in_s_out_o_send, \ + NULL, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Users.ListByAttr */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Users_ListByAttr(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char *, uint32_t, const char ***); \ + sbus_method_sync("ListByAttr", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByAttr, \ + NULL, \ + _sbus_ifp_invoke_in_ssu_out_ao_send, \ + _sbus_ifp_key_ssu_0_1_2, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Users_ListByAttr(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *, const char *, uint32_t); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListByAttr", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByAttr, \ + NULL, \ + _sbus_ifp_invoke_in_ssu_out_ao_send, \ + _sbus_ifp_key_ssu_0_1_2, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Users.ListByCertificate */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Users_ListByCertificate(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, uint32_t, const char ***); \ + sbus_method_sync("ListByCertificate", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByCertificate, \ + NULL, \ + _sbus_ifp_invoke_in_su_out_ao_send, \ + NULL, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Users_ListByCertificate(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *, uint32_t); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListByCertificate", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByCertificate, \ + NULL, \ + _sbus_ifp_invoke_in_su_out_ao_send, \ + NULL, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Users.ListByDomainAndName */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Users_ListByDomainAndName(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, const char *, uint32_t, const char ***); \ + sbus_method_sync("ListByDomainAndName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByDomainAndName, \ + NULL, \ + _sbus_ifp_invoke_in_ssu_out_ao_send, \ + _sbus_ifp_key_ssu_0_1_2, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Users_ListByDomainAndName(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *, const char *, uint32_t); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListByDomainAndName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByDomainAndName, \ + NULL, \ + _sbus_ifp_invoke_in_ssu_out_ao_send, \ + _sbus_ifp_key_ssu_0_1_2, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Users.ListByName */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Users_ListByName(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char *, uint32_t, const char ***); \ + sbus_method_sync("ListByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByName, \ + NULL, \ + _sbus_ifp_invoke_in_su_out_ao_send, \ + _sbus_ifp_key_su_0_1, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Users_ListByName(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data), const char *, uint32_t); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_method_async("ListByName", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByName, \ + NULL, \ + _sbus_ifp_invoke_in_su_out_ao_send, \ + _sbus_ifp_key_su_0_1, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Interface: org.freedesktop.sssd.infopipe.Users.User */ +#define SBUS_IFACE_org_freedesktop_sssd_infopipe_Users_User(methods, signals, properties) ({ \ + sbus_interface("org.freedesktop.sssd.infopipe.Users.User", NULL, \ + (methods), (signals), (properties)); \ +}) + +/* Method: org.freedesktop.sssd.infopipe.Users.User.UpdateGroupsList */ +#define SBUS_METHOD_SYNC_org_freedesktop_sssd_infopipe_Users_User_UpdateGroupsList(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_method_sync("UpdateGroupsList", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_User_UpdateGroupsList, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + _sbus_ifp_key_, \ + (handler), (data)); \ +}) + +#define SBUS_METHOD_ASYNC_org_freedesktop_sssd_infopipe_Users_User_UpdateGroupsList(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_method_async("UpdateGroupsList", \ + &_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_User_UpdateGroupsList, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + _sbus_ifp_key_, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.domain */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_domain(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("domain", "o", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_o_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_domain(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("domain", "o", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_o_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_domain(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("domain", "o", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_domain(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("domain", "o", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.domainname */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_domainname(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("domainname", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_domainname(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("domainname", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_domainname(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("domainname", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_domainname(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("domainname", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.extraAttributes */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_extraAttributes(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), hash_table_t **); \ + sbus_property_sync("extraAttributes", "a{sas}", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_ifp_extra_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_extraAttributes(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), hash_table_t **); \ + sbus_property_async("extraAttributes", "a{sas}", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_ifp_extra_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_extraAttributes(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("extraAttributes", "a{sas}", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_extraAttributes(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("extraAttributes", "a{sas}", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.gecos */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_gecos(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("gecos", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_gecos(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("gecos", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_gecos(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("gecos", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_gecos(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("gecos", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.gidNumber */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_gidNumber(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), uint32_t*); \ + sbus_property_sync("gidNumber", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_gidNumber(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), uint32_t*); \ + sbus_property_async("gidNumber", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_gidNumber(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("gidNumber", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_gidNumber(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("gidNumber", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.groups */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_groups(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char ***); \ + sbus_property_sync("groups", "ao", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_groups(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char ***); \ + sbus_property_async("groups", "ao", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_ao_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_groups(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("groups", "ao", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_groups(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("groups", "ao", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.homeDirectory */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_homeDirectory(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("homeDirectory", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_homeDirectory(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("homeDirectory", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_homeDirectory(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("homeDirectory", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_homeDirectory(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("homeDirectory", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.loginShell */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_loginShell(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("loginShell", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_loginShell(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("loginShell", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_loginShell(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("loginShell", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_loginShell(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("loginShell", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.name */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_name(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("name", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_name(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("name", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_name(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("name", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_name(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("name", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.uidNumber */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_uidNumber(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), uint32_t*); \ + sbus_property_sync("uidNumber", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_uidNumber(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), uint32_t*); \ + sbus_property_async("uidNumber", "u", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_u_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_uidNumber(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("uidNumber", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_uidNumber(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("uidNumber", "u", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +/* Property: org.freedesktop.sssd.infopipe.Users.User.uniqueID */ +#define SBUS_GETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_uniqueID(handler, data) ({ \ + SBUS_CHECK_SYNC((handler), (data), const char **); \ + sbus_property_sync("uniqueID", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler), (data)); \ +}) + +#define SBUS_GETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_uniqueID(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv), const char **); \ + sbus_property_async("uniqueID", "s", SBUS_PROPERTY_READABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out_s_send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#define SBUS_SETTER_SYNC_org_freedesktop_sssd_infopipe_Users_User_uniqueID(handler, data) ({\ + SBUS_CHECK_SYNC((handler), (data)); \ + sbus_property_sync("uniqueID", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler), (data)); \ +}) + +#define SBUS_SETTER_ASYNC_org_freedesktop_sssd_infopipe_Users_User_uniqueID(handler_send, handler_recv, data) ({ \ + SBUS_CHECK_SEND((handler_send), (data)); \ + SBUS_CHECK_RECV((handler_recv)); \ + sbus_property_async("uniqueID", "s", SBUS_PROPERTY_WRITABLE, \ + NULL, \ + _sbus_ifp_invoke_in__out__send, \ + (handler_send), (handler_recv), (data)); \ +}) + +#endif /* _SBUS_IFP_INTERFACE_H_ */ diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_invokers.c b/src/responder/ifp/ifp_iface/sbus_ifp_invokers.c new file mode 100644 index 0000000..a2db826 --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_invokers.c @@ -0,0 +1,3004 @@ +/* + 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 "responder/ifp/ifp_iface/sbus_ifp_arguments.h" +#include "responder/ifp/ifp_iface/sbus_ifp_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_ifp_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_ifp_invoke_in__out__step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in__out__done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_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_ifp_invoke_in__out__state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_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_ifp_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_ifp_invoke_in__out__step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_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_ifp_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_ifp_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_ifp_invoke_in__out__done(struct tevent_req *subreq) +{ + struct _sbus_ifp_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_ifp_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_ifp_invoke_in__out_ao_state { + struct _sbus_ifp_invoker_args_ao out; + 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 *); + 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_ifp_invoke_in__out_ao_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in__out_ao_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in__out_ao_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_ifp_invoke_in__out_ao_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in__out_ao_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_ifp_invoke_in__out_ao_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_ifp_invoke_in__out_ao_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in__out_ao_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_ifp_invoke_in__out_ao_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_ifp_invoker_write_ao(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_ifp_invoke_in__out_ao_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_ifp_invoke_in__out_ao_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in__out_ao_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_ifp_invoke_in__out_ao_state); + + ret = state->handler.recv(state, subreq, &state->out.arg0); + talloc_zfree(subreq); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + ret = _sbus_ifp_invoker_write_ao(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in__out_as_state { + struct _sbus_ifp_invoker_args_as out; + 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 *); + 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_ifp_invoke_in__out_as_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in__out_as_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in__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_ifp_invoke_in__out_as_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in__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; + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_invoke_in__out_as_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_ifp_invoke_in__out_as_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in__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_ifp_invoke_in__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->out.arg0); + if (ret != EOK) { + goto done; + } + + ret = _sbus_ifp_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); + if (subreq == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n"); + ret = ENOMEM; + goto done; + } + + tevent_req_set_callback(subreq, _sbus_ifp_invoke_in__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_ifp_invoke_in__out_as_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in__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_ifp_invoke_in__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_ifp_invoker_write_as(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in__out_b_state { + struct _sbus_ifp_invoker_args_b out; + struct { + enum sbus_handler_type type; + void *data; + errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, bool*); + struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *); + errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, bool*); + } handler; + + struct sbus_request *sbus_req; + DBusMessageIter *read_iterator; + DBusMessageIter *write_iterator; +}; + +static void +_sbus_ifp_invoke_in__out_b_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in__out_b_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in__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_ifp_invoke_in__out_b_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in__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; + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_invoke_in__out_b_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_ifp_invoke_in__out_b_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in__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_ifp_invoke_in__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->out.arg0); + if (ret != EOK) { + goto done; + } + + ret = _sbus_ifp_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); + if (subreq == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n"); + ret = ENOMEM; + goto done; + } + + tevent_req_set_callback(subreq, _sbus_ifp_invoke_in__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_ifp_invoke_in__out_b_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in__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_ifp_invoke_in__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_ifp_invoker_write_b(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in__out_ifp_extra_state { + struct _sbus_ifp_invoker_args_ifp_extra out; + struct { + enum sbus_handler_type type; + void *data; + errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, hash_table_t **); + struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *); + errno_t (*recv)(TALLOC_CTX *, struct tevent_req *, hash_table_t **); + } handler; + + struct sbus_request *sbus_req; + DBusMessageIter *read_iterator; + DBusMessageIter *write_iterator; +}; + +static void +_sbus_ifp_invoke_in__out_ifp_extra_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in__out_ifp_extra_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in__out_ifp_extra_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_ifp_invoke_in__out_ifp_extra_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in__out_ifp_extra_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_ifp_invoke_in__out_ifp_extra_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_ifp_invoke_in__out_ifp_extra_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in__out_ifp_extra_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_ifp_invoke_in__out_ifp_extra_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_ifp_invoker_write_ifp_extra(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_ifp_invoke_in__out_ifp_extra_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_ifp_invoke_in__out_ifp_extra_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in__out_ifp_extra_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_ifp_invoke_in__out_ifp_extra_state); + + ret = state->handler.recv(state, subreq, &state->out.arg0); + talloc_zfree(subreq); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + ret = _sbus_ifp_invoker_write_ifp_extra(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in__out_o_state { + struct _sbus_ifp_invoker_args_o out; + 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 *); + 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_ifp_invoke_in__out_o_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in__out_o_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in__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_ifp_invoke_in__out_o_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in__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; + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_invoke_in__out_o_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_ifp_invoke_in__out_o_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in__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_ifp_invoke_in__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->out.arg0); + if (ret != EOK) { + goto done; + } + + ret = _sbus_ifp_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); + if (subreq == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n"); + ret = ENOMEM; + goto done; + } + + tevent_req_set_callback(subreq, _sbus_ifp_invoke_in__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_ifp_invoke_in__out_o_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in__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_ifp_invoke_in__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_ifp_invoker_write_o(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in__out_s_state { + struct _sbus_ifp_invoker_args_s out; + 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 *); + 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_ifp_invoke_in__out_s_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in__out_s_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in__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_ifp_invoke_in__out_s_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in__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; + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_invoke_in__out_s_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_ifp_invoke_in__out_s_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in__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_ifp_invoke_in__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->out.arg0); + if (ret != EOK) { + goto done; + } + + ret = _sbus_ifp_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); + if (subreq == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n"); + ret = ENOMEM; + goto done; + } + + tevent_req_set_callback(subreq, _sbus_ifp_invoke_in__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_ifp_invoke_in__out_s_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in__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_ifp_invoke_in__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_ifp_invoker_write_s(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in__out_u_state { + struct _sbus_ifp_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_ifp_invoke_in__out_u_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in__out_u_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_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_ifp_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_ifp_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_ifp_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_ifp_invoke_in__out_u_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_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_ifp_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_ifp_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_ifp_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_ifp_invoke_in__out_u_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_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_ifp_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_ifp_invoker_write_u(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in_s_out_ao_state { + struct _sbus_ifp_invoker_args_s *in; + struct _sbus_ifp_invoker_args_ao 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_ifp_invoke_in_s_out_ao_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in_s_out_ao_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in_s_out_ao_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_ifp_invoke_in_s_out_ao_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in_s_out_ao_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_ifp_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_ifp_invoker_read_s(state, read_iterator, state->in); + if (ret != EOK) { + goto done; + } + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_invoke_in_s_out_ao_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_ifp_invoke_in_s_out_ao_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in_s_out_ao_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_ifp_invoke_in_s_out_ao_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_ifp_invoker_write_ao(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_ifp_invoke_in_s_out_ao_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_ifp_invoke_in_s_out_ao_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in_s_out_ao_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_ifp_invoke_in_s_out_ao_state); + + ret = state->handler.recv(state, subreq, &state->out.arg0); + talloc_zfree(subreq); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + ret = _sbus_ifp_invoker_write_ao(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in_s_out_as_state { + struct _sbus_ifp_invoker_args_s *in; + struct _sbus_ifp_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_ifp_invoke_in_s_out_as_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in_s_out_as_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_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_ifp_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_ifp_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_ifp_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_ifp_invoker_read_s(state, read_iterator, state->in); + if (ret != EOK) { + goto done; + } + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_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_ifp_invoke_in_s_out_as_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_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_ifp_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_ifp_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_ifp_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_ifp_invoke_in_s_out_as_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_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_ifp_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_ifp_invoker_write_as(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in_s_out_o_state { + struct _sbus_ifp_invoker_args_s *in; + struct _sbus_ifp_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 **); + 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_ifp_invoke_in_s_out_o_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in_s_out_o_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in_s_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_ifp_invoke_in_s_out_o_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in_s_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_ifp_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_ifp_invoker_read_s(state, read_iterator, state->in); + if (ret != EOK) { + goto done; + } + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_invoke_in_s_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_ifp_invoke_in_s_out_o_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in_s_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_ifp_invoke_in_s_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->out.arg0); + if (ret != EOK) { + goto done; + } + + ret = _sbus_ifp_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); + if (subreq == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n"); + ret = ENOMEM; + goto done; + } + + tevent_req_set_callback(subreq, _sbus_ifp_invoke_in_s_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_ifp_invoke_in_s_out_o_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in_s_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_ifp_invoke_in_s_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_ifp_invoker_write_o(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in_s_out_s_state { + struct _sbus_ifp_invoker_args_s *in; + struct _sbus_ifp_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_ifp_invoke_in_s_out_s_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in_s_out_s_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_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_ifp_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_ifp_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_ifp_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_ifp_invoker_read_s(state, read_iterator, state->in); + if (ret != EOK) { + goto done; + } + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_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_ifp_invoke_in_s_out_s_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_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_ifp_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_ifp_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_ifp_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_ifp_invoke_in_s_out_s_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_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_ifp_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_ifp_invoker_write_s(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in_sas_out_raw_state { + struct _sbus_ifp_invoker_args_sas *in; + struct { + enum sbus_handler_type type; + void *data; + errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *, const char **, DBusMessageIter *); + struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, const char *, const char **, DBusMessageIter *); + errno_t (*recv)(TALLOC_CTX *, struct tevent_req *); + } handler; + + struct sbus_request *sbus_req; + DBusMessageIter *read_iterator; + DBusMessageIter *write_iterator; +}; + +static void +_sbus_ifp_invoke_in_sas_out_raw_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in_sas_out_raw_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in_sas_out_raw_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_ifp_invoke_in_sas_out_raw_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in_sas_out_raw_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_ifp_invoker_args_sas); + if (state->in == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, + "Unable to allocate space for input parameters!\n"); + ret = ENOMEM; + goto done; + } + + ret = _sbus_ifp_invoker_read_sas(state, read_iterator, state->in); + if (ret != EOK) { + goto done; + } + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_invoke_in_sas_out_raw_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_ifp_invoke_in_sas_out_raw_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in_sas_out_raw_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_ifp_invoke_in_sas_out_raw_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->write_iterator); + 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->write_iterator); + if (subreq == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n"); + ret = ENOMEM; + goto done; + } + + tevent_req_set_callback(subreq, _sbus_ifp_invoke_in_sas_out_raw_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_ifp_invoke_in_sas_out_raw_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in_sas_out_raw_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_ifp_invoke_in_sas_out_raw_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_ifp_invoke_in_ss_out_o_state { + struct _sbus_ifp_invoker_args_ss *in; + struct _sbus_ifp_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_ifp_invoke_in_ss_out_o_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in_ss_out_o_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_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_ifp_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_ifp_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_ifp_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_ifp_invoker_read_ss(state, read_iterator, state->in); + if (ret != EOK) { + goto done; + } + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_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_ifp_invoke_in_ss_out_o_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_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_ifp_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_ifp_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_ifp_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_ifp_invoke_in_ss_out_o_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_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_ifp_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_ifp_invoker_write_o(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in_ssu_out_ao_state { + struct _sbus_ifp_invoker_args_ssu *in; + struct _sbus_ifp_invoker_args_ao out; + struct { + enum sbus_handler_type type; + void *data; + errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *, const char *, uint32_t, const char ***); + 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 *, const char ***); + } handler; + + struct sbus_request *sbus_req; + DBusMessageIter *read_iterator; + DBusMessageIter *write_iterator; +}; + +static void +_sbus_ifp_invoke_in_ssu_out_ao_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in_ssu_out_ao_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in_ssu_out_ao_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_ifp_invoke_in_ssu_out_ao_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in_ssu_out_ao_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_ifp_invoker_args_ssu); + if (state->in == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, + "Unable to allocate space for input parameters!\n"); + ret = ENOMEM; + goto done; + } + + ret = _sbus_ifp_invoker_read_ssu(state, read_iterator, state->in); + if (ret != EOK) { + goto done; + } + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_invoke_in_ssu_out_ao_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_ifp_invoke_in_ssu_out_ao_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in_ssu_out_ao_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_ifp_invoke_in_ssu_out_ao_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_ifp_invoker_write_ao(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_ifp_invoke_in_ssu_out_ao_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_ifp_invoke_in_ssu_out_ao_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in_ssu_out_ao_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_ifp_invoke_in_ssu_out_ao_state); + + ret = state->handler.recv(state, subreq, &state->out.arg0); + talloc_zfree(subreq); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + ret = _sbus_ifp_invoker_write_ao(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in_su_out_ao_state { + struct _sbus_ifp_invoker_args_su *in; + struct _sbus_ifp_invoker_args_ao out; + struct { + enum sbus_handler_type type; + void *data; + errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, const char *, uint32_t, const char ***); + struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, const char *, uint32_t); + 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_ifp_invoke_in_su_out_ao_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in_su_out_ao_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in_su_out_ao_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_ifp_invoke_in_su_out_ao_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in_su_out_ao_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_ifp_invoker_args_su); + if (state->in == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, + "Unable to allocate space for input parameters!\n"); + ret = ENOMEM; + goto done; + } + + ret = _sbus_ifp_invoker_read_su(state, read_iterator, state->in); + if (ret != EOK) { + goto done; + } + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_invoke_in_su_out_ao_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_ifp_invoke_in_su_out_ao_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in_su_out_ao_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_ifp_invoke_in_su_out_ao_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_ifp_invoker_write_ao(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_ifp_invoke_in_su_out_ao_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_ifp_invoke_in_su_out_ao_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in_su_out_ao_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_ifp_invoke_in_su_out_ao_state); + + ret = state->handler.recv(state, subreq, &state->out.arg0); + talloc_zfree(subreq); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + ret = _sbus_ifp_invoker_write_ao(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} + +struct _sbus_ifp_invoke_in_u_out_o_state { + struct _sbus_ifp_invoker_args_u *in; + struct _sbus_ifp_invoker_args_o out; + struct { + enum sbus_handler_type type; + void *data; + errno_t (*sync)(TALLOC_CTX *, struct sbus_request *, void *, uint32_t, const char **); + struct tevent_req * (*send)(TALLOC_CTX *, struct tevent_context *, struct sbus_request *, void *, uint32_t); + 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_ifp_invoke_in_u_out_o_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data); + +static void +_sbus_ifp_invoke_in_u_out_o_done + (struct tevent_req *subreq); + +struct tevent_req * +_sbus_ifp_invoke_in_u_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_ifp_invoke_in_u_out_o_state *state; + struct tevent_req *req; + const char *key; + errno_t ret; + + req = tevent_req_create(mem_ctx, &state, struct _sbus_ifp_invoke_in_u_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_ifp_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_ifp_invoker_read_u(state, read_iterator, state->in); + if (ret != EOK) { + goto done; + } + + ret = sbus_invoker_schedule(state, ev, _sbus_ifp_invoke_in_u_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_ifp_invoke_in_u_out_o_step + (struct tevent_context *ev, + struct tevent_timer *te, + struct timeval tv, + void *private_data) +{ + struct _sbus_ifp_invoke_in_u_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_ifp_invoke_in_u_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->out.arg0); + if (ret != EOK) { + goto done; + } + + ret = _sbus_ifp_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); + if (subreq == NULL) { + DEBUG(SSSDBG_CRIT_FAILURE, "Unable to create subrequest!\n"); + ret = ENOMEM; + goto done; + } + + tevent_req_set_callback(subreq, _sbus_ifp_invoke_in_u_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_ifp_invoke_in_u_out_o_done(struct tevent_req *subreq) +{ + struct _sbus_ifp_invoke_in_u_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_ifp_invoke_in_u_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_ifp_invoker_write_o(state->write_iterator, &state->out); + if (ret != EOK) { + tevent_req_error(req, ret); + return; + } + + tevent_req_done(req); + return; +} diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_invokers.h b/src/responder/ifp/ifp_iface/sbus_ifp_invokers.h new file mode 100644 index 0000000..12d8f22 --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_invokers.h @@ -0,0 +1,60 @@ +/* + 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_IFP_INVOKERS_H_ +#define _SBUS_IFP_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_ifp_declare_invoker(input, output) \ + struct tevent_req * \ + _sbus_ifp_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_ifp_declare_invoker(, ); +_sbus_ifp_declare_invoker(, ao); +_sbus_ifp_declare_invoker(, as); +_sbus_ifp_declare_invoker(, b); +_sbus_ifp_declare_invoker(, ifp_extra); +_sbus_ifp_declare_invoker(, o); +_sbus_ifp_declare_invoker(, s); +_sbus_ifp_declare_invoker(, u); +_sbus_ifp_declare_invoker(s, ao); +_sbus_ifp_declare_invoker(s, as); +_sbus_ifp_declare_invoker(s, o); +_sbus_ifp_declare_invoker(s, s); +_sbus_ifp_declare_invoker(sas, raw); +_sbus_ifp_declare_invoker(ss, o); +_sbus_ifp_declare_invoker(ssu, ao); +_sbus_ifp_declare_invoker(su, ao); +_sbus_ifp_declare_invoker(u, o); + +#endif /* _SBUS_IFP_INVOKERS_H_ */ diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_keygens.c b/src/responder/ifp/ifp_iface/sbus_ifp_keygens.c new file mode 100644 index 0000000..0f2f4ae --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_keygens.c @@ -0,0 +1,107 @@ +/* + 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 "responder/ifp/ifp_iface/sbus_ifp_arguments.h" +#include "responder/ifp/ifp_iface/sbus_ifp_keygens.h" + +const char * +_sbus_ifp_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_ifp_key_s_0 + (TALLOC_CTX *mem_ctx, + struct sbus_request *sbus_req, + struct _sbus_ifp_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_ifp_key_ssu_0_1_2 + (TALLOC_CTX *mem_ctx, + struct sbus_request *sbus_req, + struct _sbus_ifp_invoker_args_ssu *args) +{ + if (sbus_req->sender == NULL) { + return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s:%s:%s:%" PRIu32 "", + 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:%s:%s:%" PRIu32 "", + 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_ifp_key_su_0_1 + (TALLOC_CTX *mem_ctx, + struct sbus_request *sbus_req, + struct _sbus_ifp_invoker_args_su *args) +{ + if (sbus_req->sender == NULL) { + return talloc_asprintf(mem_ctx, "-:%u:%s.%s:%s:%s:%" PRIu32 "", + 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:%s:%" PRIu32 "", + sbus_req->sender->uid, sbus_req->type, sbus_req->interface, sbus_req->member, + sbus_req->path, args->arg0, args->arg1); +} + +const char * +_sbus_ifp_key_u_0 + (TALLOC_CTX *mem_ctx, + struct sbus_request *sbus_req, + struct _sbus_ifp_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); +} diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_keygens.h b/src/responder/ifp/ifp_iface/sbus_ifp_keygens.h new file mode 100644 index 0000000..a0e5fb2 --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_keygens.h @@ -0,0 +1,57 @@ +/* + 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_IFP_KEYGENS_H_ +#define _SBUS_IFP_KEYGENS_H_ + +#include <talloc.h> + +#include "sbus/sbus_request.h" +#include "responder/ifp/ifp_iface/sbus_ifp_arguments.h" + +const char * +_sbus_ifp_key_ + (TALLOC_CTX *mem_ctx, + struct sbus_request *sbus_req); + +const char * +_sbus_ifp_key_s_0 + (TALLOC_CTX *mem_ctx, + struct sbus_request *sbus_req, + struct _sbus_ifp_invoker_args_s *args); + +const char * +_sbus_ifp_key_ssu_0_1_2 + (TALLOC_CTX *mem_ctx, + struct sbus_request *sbus_req, + struct _sbus_ifp_invoker_args_ssu *args); + +const char * +_sbus_ifp_key_su_0_1 + (TALLOC_CTX *mem_ctx, + struct sbus_request *sbus_req, + struct _sbus_ifp_invoker_args_su *args); + +const char * +_sbus_ifp_key_u_0 + (TALLOC_CTX *mem_ctx, + struct sbus_request *sbus_req, + struct _sbus_ifp_invoker_args_u *args); + +#endif /* _SBUS_IFP_KEYGENS_H_ */ diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_server.h b/src/responder/ifp/ifp_iface/sbus_ifp_server.h new file mode 100644 index 0000000..4f65ea6 --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_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_IFP_SERVER_H_ +#define _SBUS_IFP_SERVER_H_ + +#include "sbus/sbus.h" +#include "sbus/sbus_interface.h" +#include "responder/ifp/ifp_iface/sbus_ifp_interface.h" + +#endif /* _SBUS_IFP_SERVER_H_ */ diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_symbols.c b/src/responder/ifp/ifp_iface/sbus_ifp_symbols.c new file mode 100644 index 0000000..a861fbc --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_symbols.c @@ -0,0 +1,436 @@ +/* + 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 "responder/ifp/ifp_iface/sbus_ifp_symbols.h" + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindBackendByName = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "name"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "backend"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindDomainByName = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "name"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "domain"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindMonitor = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "monitor"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindResponderByName = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "name"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "responder"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_GetUserAttr = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "user"}, + {.type = "as", .name = "attr"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "a{sv}", .name = "values"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_GetUserGroups = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "user"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "as", .name = "values"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListBackends = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "backends"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListComponents = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "components"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListDomains = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "domain"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListResponders = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "responders"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Ping = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "ping"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "s", .name = "pong"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_List = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_ListByDomain = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "domain_name"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_Object_Remove = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "b", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_Object_Store = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "b", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ActiveServer = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "service"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "s", .name = "server"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_IsOnline = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "b", .name = "status"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_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_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ListServices = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "as", .name = "services"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_RefreshAccessRules = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_FindByID = { + .input = (const struct sbus_argument[]){ + {.type = "u", .name = "id"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_FindByName = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "name"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_ListByDomainAndName = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "domain_name"}, + {.type = "s", .name = "name_filter"}, + {.type = "u", .name = "limit"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_ListByName = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "name_filter"}, + {.type = "u", .name = "limit"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_Group_UpdateMemberList = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByCertificate = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "pem_cert"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByID = { + .input = (const struct sbus_argument[]){ + {.type = "u", .name = "id"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByName = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "name"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByNameAndCertificate = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "name"}, + {.type = "s", .name = "pem_cert"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByValidCertificate = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "pem_cert"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "o", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByAttr = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "attribute"}, + {.type = "s", .name = "attr_filter"}, + {.type = "u", .name = "limit"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByCertificate = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "pem_cert"}, + {.type = "u", .name = "limit"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByDomainAndName = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "domain_name"}, + {.type = "s", .name = "name_filter"}, + {.type = "u", .name = "limit"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByName = { + .input = (const struct sbus_argument[]){ + {.type = "s", .name = "name_filter"}, + {.type = "u", .name = "limit"}, + {NULL} + }, + .output = (const struct sbus_argument[]){ + {.type = "ao", .name = "result"}, + {NULL} + } +}; + +const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_User_UpdateGroupsList = { + .input = (const struct sbus_argument[]){ + {NULL} + }, + .output = (const struct sbus_argument[]){ + {NULL} + } +}; diff --git a/src/responder/ifp/ifp_iface/sbus_ifp_symbols.h b/src/responder/ifp/ifp_iface/sbus_ifp_symbols.h new file mode 100644 index 0000000..f433fa7 --- /dev/null +++ b/src/responder/ifp/ifp_iface/sbus_ifp_symbols.h @@ -0,0 +1,130 @@ +/* + 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_IFP_SYMBOLS_H_ +#define _SBUS_IFP_SYMBOLS_H_ + +#include "sbus/sbus_interface_declarations.h" + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindBackendByName; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindDomainByName; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindMonitor; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_FindResponderByName; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_GetUserAttr; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_GetUserGroups; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListBackends; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListComponents; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListDomains; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_ListResponders; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Ping; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_List; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_ListByDomain; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_Object_Remove; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Cache_Object_Store; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ActiveServer; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_IsOnline; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ListServers; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_ListServices; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Domains_Domain_RefreshAccessRules; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_FindByID; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_FindByName; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_ListByDomainAndName; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_ListByName; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Groups_Group_UpdateMemberList; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByCertificate; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByID; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByName; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByNameAndCertificate; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_FindByValidCertificate; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByAttr; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByCertificate; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByDomainAndName; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_ListByName; + +extern const struct sbus_method_arguments +_sbus_ifp_args_org_freedesktop_sssd_infopipe_Users_User_UpdateGroupsList; + +#endif /* _SBUS_IFP_SYMBOLS_H_ */ |