Reconstruct rule with xml format.
Change-Id: I760f5c89f519672743a10fa15b66ac14b7e819a1
Signed-off-by: sanghyeok.oh <sanghyeok.oh@samsung.com>
dbus_bool_t requested_reply,
dbus_bool_t log,
const char *privilege,
- DBusError *error)
+ DBusError *error,
+ const char *rule)
{
DBusError stack_error = DBUS_ERROR_INIT;
const char *sender_name;
"%s, %d matched rules; type=\"%s\", sender=\"%s\" (%s) "
"interface=\"%s\" member=\"%s\" error name=\"%s\" "
"requested_reply=\"%d\" destination=\"%s\" "
- "privilege=\"%s\" (%s)",
+ "privilege=\"%s\" (%s) "
+ "rule(%s)",
complaint,
matched_rules,
dbus_message_type_to_string (dbus_message_get_type (message)),
requested_reply,
nonnull (dbus_message_get_destination (message), DBUS_SERVICE_DBUS),
nonnull (privilege, "(n/a)"),
- proposed_recipient_loginfo);
+ proposed_recipient_loginfo,
+ rule);
/* If we hit OOM while setting the error, this will syslog "out of memory"
* which is itself an indication that something is seriously wrong */
int type;
dbus_bool_t requested_reply;
const char *privilege;
+ char *out_rule = NULL;
type = dbus_message_get_type (message);
src = dbus_message_get_sender (message);
complain_about_message (context, DBUS_ERROR_ACCESS_DENIED,
"An SELinux policy prevents this sender from sending this "
"message to this recipient",
- 0, message, sender, proposed_recipient, FALSE, FALSE, NULL, error);
+ 0, message, sender, proposed_recipient, FALSE, FALSE, NULL, error, NULL);
_dbus_verbose ("SELinux security check denying send to service\n");
}
addressed_recipient,
proposed_recipient,
message, &toggles, &log, &privilege,
- deferred_message))
+ deferred_message, &out_rule))
{
case BUS_RESULT_TRUE:
break;
"Rejected send message", toggles,
message, sender, proposed_recipient, requested_reply,
(addressed_recipient == proposed_recipient), privilege,
- error);
+ error, out_rule);
_dbus_verbose ("security policy disallowing message due to sender policy\n");
+ if (out_rule)
+ free (out_rule);
return BUS_RESULT_FALSE;
break;
case BUS_RESULT_LATER:
complain_about_message (context, DBUS_ERROR_ACCESS_DENIED,
"Would reject message", toggles,
message, sender, proposed_recipient, requested_reply,
- TRUE, privilege, NULL);
+ TRUE, privilege, NULL, NULL);
}
if (recipient_policy) {
requested_reply,
sender,
addressed_recipient, proposed_recipient,
- message, &toggles, &privilege, deferred_message))
+ message, &toggles, &privilege, deferred_message, &out_rule))
{
case BUS_RESULT_TRUE:
break;
complain_about_message(context, DBUS_ERROR_ACCESS_DENIED,
"Rejected receive message", toggles, message, sender,
proposed_recipient, requested_reply,
- (addressed_recipient == proposed_recipient), privilege, error);
+ (addressed_recipient == proposed_recipient), privilege, error, out_rule);
_dbus_verbose(
"security policy disallowing message due to recipient policy\n");
+ if (out_rule)
+ free (out_rule);
return BUS_RESULT_FALSE;
case BUS_RESULT_LATER:
return BUS_RESULT_LATER;
DBusError *error)
{
complain_about_message(context, error_name, complaint, matched_rules, message, sender,
- proposed_recipient, requested_reply, log, privilege, error);
+ proposed_recipient, requested_reply, log, privilege, error, NULL);
}
dbus_bool_t bus_context_check_recipient_message_limits (BusContext *context,
complain_about_message (context, DBUS_ERROR_LIMITS_EXCEEDED,
"Rejected: destination has a full message queue",
0, message, sender, recipient, requested_reply, TRUE, NULL,
- error);
+ error, NULL);
_dbus_verbose ("security policy disallowing message due to full message queue\n");
return FALSE;
}
deferred_message->response = bus_client_policy_check_can_receive(recipient_policy, registry,
deferred_message->requested_reply, deferred_message->sender,
deferred_message->addressed_recipient, deferred_message->proposed_recipient, deferred_message->message,
- &toggles, NULL, &deferred_message_receive);
+ &toggles, NULL, &deferred_message_receive, NULL);
if (deferred_message->response == BUS_RESULT_LATER)
{
/* replace deferred message associated with send check with the one associated with
return TRUE;
}
+#define _dbus_string_append_printf_err_check(str, fmt, args...) \
+ if (!_dbus_string_append_printf(str, fmt, ##args)) \
+ { \
+ _dbus_string_free (str); \
+ return FALSE; \
+ }
+
+dbus_bool_t bus_policy_rule_to_string (BusPolicyRule *rule,
+ char **out_rule)
+{
+ const char *sr;
+ const char *access;
+ const char *dest;
+ const char *msg_type[] = {"Invalid", "method_call", "method_return", "signal", "error"};
+ DBusString str;
+
+ *out_rule = NULL;
+
+ switch (rule->access)
+ {
+ case BUS_POLICY_RULE_ACCESS_ALLOW:
+ access = "allow";
+ break;
+ case BUS_POLICY_RULE_ACCESS_DENY:
+ access = "deny";
+ break;
+ case BUS_POLICY_RULE_ACCESS_CHECK:
+ access = "check";
+ break;
+ }
+
+ if (rule->type == BUS_POLICY_RULE_SEND)
+ {
+ sr = "send";
+ dest = "destination";
+ }
+ else if (rule->type == BUS_POLICY_RULE_RECEIVE)
+ {
+ sr = "receive";
+ dest = "sender";
+ }
+ else
+ return FALSE;
+
+ /* generate xml format */
+ if (!_dbus_string_init (&str))
+ return FALSE;
+
+ _dbus_string_append_printf_err_check (&str, "<%s ", access);
+
+ if (rule->d.send.destination_prefix)
+ {
+ _dbus_string_append_printf_err_check (&str, "%s_destination_prefix=\"%s\" ", sr, rule->d.send.destination);
+ }
+ else if (rule->d.send.destination)
+ {
+ _dbus_string_append_printf_err_check (&str, "%s_%s=\"%s\" ", sr, dest, rule->d.send.destination);
+ }
+
+ if (rule->d.send.path)
+ _dbus_string_append_printf_err_check (&str, "%s_path=\"%s\" ", sr, rule->d.send.path);
+ if (rule->d.send.interface)
+ _dbus_string_append_printf_err_check (&str, "%s_interface=\"%s\" ", sr, rule->d.send.interface);
+ if (rule->d.send.member)
+ _dbus_string_append_printf_err_check (&str, "%s_member=\"%s\" ", sr, rule->d.send.member);
+ if (rule->d.send.message_type)
+ _dbus_string_append_printf_err_check (&str, "%s_type=\"%s\" ", sr, msg_type[rule->d.send.message_type]);
+ if (rule->privilege)
+ _dbus_string_append_printf_err_check (&str, "privilege=\"%s\" ", rule->privilege);
+
+ if (!_dbus_string_append (&str, "/>"))
+ {
+ _dbus_string_free (&str);
+ return FALSE;
+ }
+
+ if (!_dbus_string_steal_data (&str, out_rule))
+ {
+ *out_rule = NULL;
+ _dbus_string_free (&str);
+ return FALSE;
+ }
+
+ _dbus_string_free (&str);
+
+ return TRUE;
+}
+
BusResult
bus_client_policy_check_can_send (DBusConnection *sender,
BusClientPolicy *policy,
dbus_int32_t *toggles,
dbus_bool_t *log,
const char **privilege_param,
- BusDeferredMessage **deferred_message)
+ BusDeferredMessage **deferred_message,
+ char **out_rule)
{
DBusList *link;
BusResult result;
const char *privilege;
+ BusPolicyRule *matched_rule = NULL;
/* policy->rules is in the order the rules appeared
* in the config file, i.e. last rule that applies wins
*log = rule->d.send.log;
(*toggles)++;
+ matched_rule = rule;
_dbus_verbose (" (policy) used rule, result now = %d\n",
result);
if (privilege_param != NULL)
*privilege_param = privilege;
+ if (result == BUS_RESULT_FALSE)
+ {
+ if (matched_rule && out_rule)
+ bus_policy_rule_to_string (matched_rule, out_rule);
+ }
+
return result;
}
DBusMessage *message,
dbus_int32_t *toggles,
const char **privilege_param,
- BusDeferredMessage **deferred_message)
+ BusDeferredMessage **deferred_message,
+ char **out_rule)
{
DBusList *link;
dbus_bool_t eavesdropping;
BusResult result;
const char *privilege;
+ BusPolicyRule *matched_rule = NULL;
eavesdropping =
addressed_recipient != proposed_recipient &&
}
(*toggles)++;
+ matched_rule = rule;
_dbus_verbose (" (policy) used rule, result now = %d\n",
result);
if (privilege_param != NULL)
*privilege_param = privilege;
+ if (result == BUS_RESULT_FALSE)
+ {
+ if (matched_rule && out_rule)
+ bus_policy_rule_to_string (matched_rule, out_rule);
+ }
+
return result;
}
dbus_int32_t *toggles,
dbus_bool_t *log,
const char **privilege_param,
- BusDeferredMessage **deferred_message);
+ BusDeferredMessage **deferred_message,
+ char **out_rule);
BusResult bus_client_policy_check_can_receive (BusClientPolicy *policy,
BusRegistry *registry,
dbus_bool_t requested_reply,
DBusMessage *message,
dbus_int32_t *toggles,
const char **privilege_param,
- BusDeferredMessage **deferred_message);
+ BusDeferredMessage **deferred_message,
+ char **out_rule);
BusResult bus_client_policy_check_can_own (BusClientPolicy *policy,
const DBusString *service_name,
DBusConnection *connection,
projects / platform / upstream / dbus.git / commitdiff