int ifp_req_create_handle_failure(struct sbus_request *dbus_req, errno_t err)
{
if (err == EACCES) {
return sbus_request_fail_and_finish(dbus_req,
sbus_error_new(dbus_req,
DBUS_ERROR_ACCESS_DENIED,
"User %"PRIi64" not in ACL\n",
dbus_req->client));
}
return sbus_request_fail_and_finish(dbus_req,
sbus_error_new(dbus_req,
DBUS_ERROR_FAILED,
"Cannot create IFP request\n"));
}
void
sbus_request_invoke_or_finish(struct sbus_request *dbus_req,
sbus_msg_handler_fn handler_fn,
void *handler_data,
sbus_method_invoker_fn invoker_fn)
{
DBusError error;
int ret;
if (invoker_fn != NULL) {
ret = invoker_fn(dbus_req, handler_fn);
} else if (handler_fn != NULL) {
ret = handler_fn(dbus_req, handler_data);
} else {
ret = EINVAL;
}
switch(ret) {
case ERR_SBUS_REQUEST_HANDLED:
case EOK:
return;
case ENOMEM:
DEBUG(SSSDBG_CRIT_FAILURE, "Out of memory handling DBus message\n");
sbus_request_finish(dbus_req, NULL);
break;
default:
DEBUG(SSSDBG_CRIT_FAILURE, "Handler failed [%d]: %s\n",
ret, sss_strerror(ret));
dbus_error_init(&error);
dbus_set_error_const(&error, DBUS_ERROR_FAILED, INTERNAL_ERROR);
sbus_request_fail_and_finish(dbus_req, &error);
break;
}
}
int sbus_introspect(struct sbus_request *dbus_req, void *pvt)
{
char *xml;
DBusError dberr;
const struct sbus_interface_meta *iface;
struct sbus_introspect_ctx *ictx;
ictx = talloc_get_type(pvt, struct sbus_introspect_ctx);
if (ictx == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE, "Invalid pointer!\n");
return sbus_request_return_and_finish(dbus_req, DBUS_TYPE_INVALID);
}
iface = ictx->iface;
xml = sbus_introspect_xml(dbus_req, iface);
if (xml == NULL) {
dbus_error_init(&dberr);
dbus_set_error_const(&dberr,
DBUS_ERROR_NO_MEMORY,
"Failed to generate introspection data\n");
return sbus_request_fail_and_finish(dbus_req, &dberr);
}
return sbus_request_return_and_finish(dbus_req,
DBUS_TYPE_STRING, &xml,
DBUS_TYPE_INVALID);
}
static void ifp_groups_list_by_name_done(struct tevent_req *req)
{
DBusError *error;
struct ifp_list_ctx *list_ctx;
struct sbus_request *sbus_req;
struct ldb_result *result;
struct sss_domain_info *domain;
errno_t ret;
list_ctx = tevent_req_callback_data(req, struct ifp_list_ctx);
sbus_req = list_ctx->sbus_req;
ret = cache_req_group_by_name_recv(sbus_req, req, &result, &domain, NULL);
talloc_zfree(req);
if (ret != EOK && ret != ENOENT) {
error = sbus_error_new(sbus_req, DBUS_ERROR_FAILED, "Failed to fetch "
"groups by filter [%d]: %s\n", ret, sss_strerror(ret));
sbus_request_fail_and_finish(sbus_req, error);
return;
}
ret = ifp_groups_list_copy(list_ctx, result);
if (ret != EOK) {
error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
"Failed to copy domain result");
sbus_request_fail_and_finish(sbus_req, error);
return;
}
list_ctx->dom = get_next_domain(list_ctx->dom, SSS_GND_DESCEND);
if (list_ctx->dom == NULL) {
return ifp_groups_list_by_name_reply(list_ctx);
}
ret = ifp_groups_list_by_name_step(list_ctx);
if (ret != EOK) {
error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
"Failed to start next-domain search");
sbus_request_fail_and_finish(sbus_req, error);
return;
}
}
static void
ifp_groups_find_by_name_done(struct tevent_req *req)
{
DBusError *error;
struct sbus_request *sbus_req;
struct sss_domain_info *domain;
struct ldb_result *result;
char *object_path;
errno_t ret;
sbus_req = tevent_req_callback_data(req, struct sbus_request);
ret = cache_req_group_by_name_recv(sbus_req, req, &result, &domain, NULL);
talloc_zfree(req);
if (ret == ENOENT) {
error = sbus_error_new(sbus_req, SBUS_ERROR_NOT_FOUND,
"Group not found");
goto done;
} else if (ret != EOK) {
error = sbus_error_new(sbus_req, DBUS_ERROR_FAILED, "Failed to fetch "
"group [%d]: %s\n", ret, sss_strerror(ret));
goto done;
}
object_path = ifp_groups_build_path_from_msg(sbus_req, domain,
result->msgs[0]);
if (object_path == NULL) {
error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
"Failed to compose object path");
goto done;
}
ret = EOK;
done:
if (ret != EOK) {
sbus_request_fail_and_finish(sbus_req, error);
return;
}
iface_ifp_groups_FindByName_finish(sbus_req, object_path);
return;
}
static void ifp_groups_list_by_domain_and_name_done(struct tevent_req *req)
{
DBusError *error;
struct ifp_list_ctx *list_ctx;
struct sbus_request *sbus_req;
struct ldb_result *result;
struct sss_domain_info *domain;
errno_t ret;
list_ctx = tevent_req_callback_data(req, struct ifp_list_ctx);
sbus_req = list_ctx->sbus_req;
ret = cache_req_user_by_name_recv(sbus_req, req, &result, &domain, NULL);
talloc_zfree(req);
if (ret == ENOENT) {
error = sbus_error_new(sbus_req, SBUS_ERROR_NOT_FOUND,
"User not found by filter");
goto done;
} else if (ret != EOK) {
error = sbus_error_new(sbus_req, DBUS_ERROR_FAILED, "Failed to fetch "
"groups by filter [%d]: %s\n", ret, sss_strerror(ret));
goto done;
}
ret = ifp_groups_list_copy(list_ctx, result);
if (ret != EOK) {
error = sbus_error_new(sbus_req, SBUS_ERROR_INTERNAL,
"Failed to copy domain result");
goto done;
}
done:
if (ret != EOK) {
sbus_request_fail_and_finish(sbus_req, error);
return;
}
iface_ifp_groups_ListByDomainAndName_finish(sbus_req,
list_ctx->paths,
list_ctx->path_count);
return;
}
int sbus_request_return_and_finish(struct sbus_request *dbus_req,
int first_arg_type,
...)
{
DBusMessage *reply;
DBusError error = DBUS_ERROR_INIT;
dbus_bool_t dbret;
va_list va;
int ret;
va_start(va, first_arg_type);
ret = sbus_request_valist_check(va, first_arg_type);
if (ret != EOK) {
va_end(va);
dbus_set_error_const(&error, DBUS_ERROR_INVALID_ARGS, INTERNAL_ERROR);
return sbus_request_fail_and_finish(dbus_req, &error);
}
reply = dbus_message_new_method_return(dbus_req->message);
if (!reply) {
va_end(va);
DEBUG(SSSDBG_CRIT_FAILURE, "Out of memory allocating DBus message\n");
sbus_request_finish(dbus_req, NULL);
return ENOMEM;
}
dbret = dbus_message_append_args_valist(reply, first_arg_type, va);
va_end(va);
if (dbret) {
ret = sbus_request_finish(dbus_req, reply);
} else {
DEBUG(SSSDBG_CRIT_FAILURE, "Couldn't build DBus message\n");
sbus_request_finish(dbus_req, NULL);
ret = EINVAL;
}
dbus_message_unref(reply);
return ret;
}
void sbus_request_reply_error(struct sbus_request *sbus_req,
const char *error_name,
const char *fmt,
...)
{
DBusError *error;
va_list ap;
va_start(ap, fmt);
error = sbus_error_new_va(sbus_req, error_name, fmt, ap);
va_end(ap);
if (error == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE,
"Unable to create D-Bus error, killing request!\n");
talloc_free(sbus_req);
return;
}
sbus_request_fail_and_finish(sbus_req, error);
}
