parser->limits.max_pending_activations = 256;
parser->limits.max_services_per_connection = 256;
+
+ parser->limits.max_match_rules_per_connection = 128;
+
+ parser->limits.reply_timeout = 5 * 60 * 1000; /* 5 minutes */
+ parser->limits.max_replies_per_connection = 32;
parser->refcount = 1;
}
}
-static int
-message_type_from_string (const char *type_str)
-{
- if (strcmp (type_str, "method_call") == 0)
- return DBUS_MESSAGE_TYPE_METHOD_CALL;
- if (strcmp (type_str, "method_return") == 0)
- return DBUS_MESSAGE_TYPE_METHOD_RETURN;
- else if (strcmp (type_str, "signal") == 0)
- return DBUS_MESSAGE_TYPE_SIGNAL;
- else if (strcmp (type_str, "error") == 0)
- return DBUS_MESSAGE_TYPE_ERROR;
- else
- return DBUS_MESSAGE_TYPE_INVALID;
-}
-
static dbus_bool_t
append_rule_from_element (BusConfigParser *parser,
const char *element_name,
const char *send_interface;
const char *send_member;
const char *send_error;
- const char *send_service;
+ const char *send_destination;
const char *send_path;
const char *send_type;
const char *receive_interface;
const char *receive_member;
const char *receive_error;
- const char *receive_service;
+ const char *receive_sender;
const char *receive_path;
const char *receive_type;
+ const char *eavesdrop;
+ const char *requested_reply;
const char *own;
const char *user;
const char *group;
"send_interface", &send_interface,
"send_member", &send_member,
"send_error", &send_error,
- "send_service", &send_service,
+ "send_destination", &send_destination,
"send_path", &send_path,
"send_type", &send_type,
"receive_interface", &receive_interface,
"receive_member", &receive_member,
"receive_error", &receive_error,
- "receive_service", &receive_service,
+ "receive_sender", &receive_sender,
"receive_path", &receive_path,
"receive_type", &receive_type,
+ "eavesdrop", &eavesdrop,
+ "requested_reply", &requested_reply,
"own", &own,
"user", &user,
"group", &group,
NULL))
return FALSE;
- if (!(send_interface || send_member || send_error || send_service ||
+ if (!(send_interface || send_member || send_error || send_destination ||
send_type || send_path ||
- receive_interface || receive_member || receive_error || receive_service ||
- receive_type || receive_path ||
+ receive_interface || receive_member || receive_error || receive_sender ||
+ receive_type || receive_path || eavesdrop || requested_reply ||
own || user || group))
{
dbus_set_error (error, DBUS_ERROR_FAILED,
* interface + member
* error
*
- * base send_ can combine with send_service, send_path, send_type
- * base receive_ with receive_service, receive_path, receive_type
+ * base send_ can combine with send_destination, send_path, send_type
+ * base receive_ with receive_sender, receive_path, receive_type, eavesdrop, requested_reply
*
* user, group, own must occur alone
+ *
+ * Pretty sure the below stuff is broken, FIXME think about it more.
*/
if (((send_interface && send_error) ||
(send_interface && receive_interface) ||
(send_interface && receive_member) ||
(send_interface && receive_error) ||
- (send_interface && receive_service) ||
+ (send_interface && receive_sender) ||
+ (send_interface && eavesdrop) ||
+ (send_interface && requested_reply) ||
(send_interface && own) ||
(send_interface && user) ||
(send_interface && group)) ||
(send_member && receive_interface) ||
(send_member && receive_member) ||
(send_member && receive_error) ||
- (send_member && receive_service) ||
+ (send_member && receive_sender) ||
+ (send_member && eavesdrop) ||
+ (send_member && requested_reply) ||
(send_member && own) ||
(send_member && user) ||
(send_member && group)) ||
((send_error && receive_interface) ||
(send_error && receive_member) ||
(send_error && receive_error) ||
- (send_error && receive_service) ||
+ (send_error && receive_sender) ||
+ (send_error && eavesdrop) ||
+ (send_error && requested_reply) ||
(send_error && own) ||
(send_error && user) ||
(send_error && group)) ||
- ((send_service && receive_interface) ||
- (send_service && receive_member) ||
- (send_service && receive_error) ||
- (send_service && receive_service) ||
- (send_service && own) ||
- (send_service && user) ||
- (send_service && group)) ||
+ ((send_destination && receive_interface) ||
+ (send_destination && receive_member) ||
+ (send_destination && receive_error) ||
+ (send_destination && receive_sender) ||
+ (send_destination && eavesdrop) ||
+ (send_destination && requested_reply) ||
+ (send_destination && own) ||
+ (send_destination && user) ||
+ (send_destination && group)) ||
((send_type && receive_interface) ||
(send_type && receive_member) ||
(send_type && receive_error) ||
- (send_type && receive_service) ||
+ (send_type && receive_sender) ||
+ (send_type && eavesdrop) ||
+ (send_type && requested_reply) ||
(send_type && own) ||
(send_type && user) ||
(send_type && group)) ||
((send_path && receive_interface) ||
(send_path && receive_member) ||
(send_path && receive_error) ||
- (send_path && receive_service) ||
+ (send_path && receive_sender) ||
+ (send_path && eavesdrop) ||
+ (send_path && requested_reply) ||
(send_path && own) ||
(send_path && user) ||
(send_path && group)) ||
(receive_member && own) ||
(receive_member && user) ||
(receive_member && group)) ||
-
+
((receive_error && own) ||
(receive_error && user) ||
(receive_error && group)) ||
+ ((eavesdrop && own) ||
+ (eavesdrop && user) ||
+ (eavesdrop && group)) ||
+
+ ((requested_reply && own) ||
+ (requested_reply && user) ||
+ (requested_reply && group)) ||
+
((own && user) ||
(own && group)) ||
((user && group)))
{
dbus_set_error (error, DBUS_ERROR_FAILED,
- "Invalid combination of attributes on element <%s>, "
- "only send_foo/send_service or receive_foo/receive_service may be paired",
+ "Invalid combination of attributes on element <%s>",
element_name);
return FALSE;
}
*/
#define IS_WILDCARD(str) ((str) && ((str)[0]) == '*' && ((str)[1]) == '\0')
- if (send_interface || send_member || send_error || send_service ||
+ if (send_interface || send_member || send_error || send_destination ||
send_path || send_type)
{
int message_type;
send_member = NULL;
if (IS_WILDCARD (send_error))
send_error = NULL;
- if (IS_WILDCARD (send_service))
- send_service = NULL;
+ if (IS_WILDCARD (send_destination))
+ send_destination = NULL;
if (IS_WILDCARD (send_path))
send_path = NULL;
if (IS_WILDCARD (send_type))
message_type = DBUS_MESSAGE_TYPE_INVALID;
if (send_type != NULL)
{
- message_type = message_type_from_string (send_type);
+ message_type = dbus_message_type_from_string (send_type);
if (message_type == DBUS_MESSAGE_TYPE_INVALID)
{
dbus_set_error (error, DBUS_ERROR_FAILED,
rule = bus_policy_rule_new (BUS_POLICY_RULE_SEND, allow);
if (rule == NULL)
goto nomem;
-
+
rule->d.send.message_type = message_type;
rule->d.send.path = _dbus_strdup (send_path);
rule->d.send.interface = _dbus_strdup (send_interface);
rule->d.send.member = _dbus_strdup (send_member);
rule->d.send.error = _dbus_strdup (send_error);
- rule->d.send.destination = _dbus_strdup (send_service);
+ rule->d.send.destination = _dbus_strdup (send_destination);
if (send_path && rule->d.send.path == NULL)
goto nomem;
if (send_interface && rule->d.send.interface == NULL)
goto nomem;
if (send_error && rule->d.send.error == NULL)
goto nomem;
- if (send_service && rule->d.send.destination == NULL)
+ if (send_destination && rule->d.send.destination == NULL)
goto nomem;
}
- else if (receive_interface || receive_member || receive_error || receive_service ||
- receive_path || receive_type)
+ else if (receive_interface || receive_member || receive_error || receive_sender ||
+ receive_path || receive_type || eavesdrop || requested_reply)
{
int message_type;
receive_member = NULL;
if (IS_WILDCARD (receive_error))
receive_error = NULL;
- if (IS_WILDCARD (receive_service))
- receive_service = NULL;
+ if (IS_WILDCARD (receive_sender))
+ receive_sender = NULL;
if (IS_WILDCARD (receive_path))
receive_path = NULL;
if (IS_WILDCARD (receive_type))
receive_type = NULL;
-
message_type = DBUS_MESSAGE_TYPE_INVALID;
if (receive_type != NULL)
{
- message_type = message_type_from_string (receive_type);
+ message_type = dbus_message_type_from_string (receive_type);
if (message_type == DBUS_MESSAGE_TYPE_INVALID)
{
dbus_set_error (error, DBUS_ERROR_FAILED,
return FALSE;
}
}
+
+
+ if (eavesdrop &&
+ !(strcmp (eavesdrop, "true") == 0 ||
+ strcmp (eavesdrop, "false") == 0))
+ {
+ dbus_set_error (error, DBUS_ERROR_FAILED,
+ "Bad value \"%s\" for %s attribute, must be true or false",
+ "eavesdrop", eavesdrop);
+ return FALSE;
+ }
+
+ if (requested_reply &&
+ !(strcmp (requested_reply, "true") == 0 ||
+ strcmp (requested_reply, "false") == 0))
+ {
+ dbus_set_error (error, DBUS_ERROR_FAILED,
+ "Bad value \"%s\" for %s attribute, must be true or false",
+ "requested_reply", requested_reply);
+ return FALSE;
+ }
rule = bus_policy_rule_new (BUS_POLICY_RULE_RECEIVE, allow);
if (rule == NULL)
goto nomem;
+ if (eavesdrop)
+ rule->d.receive.eavesdrop = (strcmp (eavesdrop, "true") == 0);
+
+ if (requested_reply)
+ rule->d.receive.requested_reply = (strcmp (requested_reply, "true") == 0);
+
rule->d.receive.message_type = message_type;
rule->d.receive.path = _dbus_strdup (receive_path);
rule->d.receive.interface = _dbus_strdup (receive_interface);
rule->d.receive.member = _dbus_strdup (receive_member);
rule->d.receive.error = _dbus_strdup (receive_error);
- rule->d.receive.origin = _dbus_strdup (receive_service);
+ rule->d.receive.origin = _dbus_strdup (receive_sender);
+
if (receive_path && rule->d.receive.path == NULL)
goto nomem;
if (receive_interface && rule->d.receive.interface == NULL)
goto nomem;
if (receive_error && rule->d.receive.error == NULL)
goto nomem;
- if (receive_service && rule->d.receive.origin == NULL)
+ if (receive_sender && rule->d.receive.origin == NULL)
goto nomem;
}
else if (own)
must_be_int = TRUE;
parser->limits.auth_timeout = value;
}
+ else if (strcmp (name, "reply_timeout") == 0)
+ {
+ must_be_positive = TRUE;
+ must_be_int = TRUE;
+ parser->limits.reply_timeout = value;
+ }
else if (strcmp (name, "max_completed_connections") == 0)
{
must_be_positive = TRUE;
must_be_int = TRUE;
parser->limits.max_services_per_connection = value;
}
+ else if (strcmp (name, "max_replies_per_connection") == 0)
+ {
+ must_be_positive = TRUE;
+ must_be_int = TRUE;
+ parser->limits.max_replies_per_connection = value;
+ }
else
{
dbus_set_error (error, DBUS_ERROR_FAILED,