1 From 9d39aa9dd55680529d721a0389ce9ef579bb669a Mon Sep 17 00:00:00 2001
2 From: Jacek Bukarewicz <j.bukarewicz@samsung.com>
3 Date: Fri, 28 Nov 2014 12:39:33 +0100
4 Subject: [PATCH 3/8] Handle unavailability of policy results for broadcasts
7 Content-Type: text/plain; charset=UTF-8
8 Content-Transfer-Encoding: 8bit
10 When message is sent to the addressed recipient and receive rule
11 result is unavailable we don't want to block the sender
12 as it most likely will be the privileged service, so instead we queue
13 it at the recipient. Any further messages sent to it will be queued to
14 maintain message order. Once the answer from Cynara arrives messages are
15 dispatched from the recipient queue. In such case full dispatch is
16 performed - messages are sent to addressed recipient and other
17 interested connections.
18 Messages sent to non-addressed recipients (eavesdroppers or broadcast
19 message recipients) are handled in a similar way. The difference is
20 that it is not full dispatch meaning message is sent to a single recipient.
22 Cherry picked from 1e231194610892dd4360224998d91336097b05a1 by Jose Bollo
24 Updated for dbus 1.10.20 by Scott Murray and José Bollo
26 Signed-off-by: José Bollo <jose.bollo@iot.bzh>
27 Signed-off-by: Scott Murray <scott.murray@konsulko.com>
29 bus/activation.c | 4 +-
30 bus/bus.c | 50 ++++++--
32 bus/check.c | 307 +++++++++++++++++++++++++++++++++++++++++++++++
34 bus/connection.c | 168 ++++++++++++++++++++++++--
35 bus/connection.h | 19 ++-
36 bus/dispatch.c | 115 +++++++++++++++---
37 bus/dispatch.h | 11 +-
40 11 files changed, 683 insertions(+), 43 deletions(-)
42 diff --git a/bus/activation.c b/bus/activation.c
43 index 8301b59..d4b597c 100644
44 --- a/bus/activation.c
45 +++ b/bus/activation.c
46 @@ -1259,7 +1259,7 @@ bus_activation_send_pending_auto_activation_messages (BusActivation *activation
47 res = bus_dispatch_matches (transaction,
50 - entry->activation_message, &error);
51 + entry->activation_message, NULL, &error);
52 if (res == BUS_RESULT_FALSE)
54 /* If permission is denied, we just want to return the error
55 @@ -2140,7 +2140,7 @@ bus_activation_activate_service (BusActivation *activation,
56 bus_connection_get_loginfo (connection));
57 /* Wonderful, systemd is connected, let's just send the msg */
58 res = bus_dispatch_matches (activation_transaction, NULL,
59 - systemd, message, error);
60 + systemd, message, NULL, error);
62 if (res == BUS_RESULT_TRUE)
64 diff --git a/bus/bus.c b/bus/bus.c
65 index 6fc45d0..0aa700b 100644
68 @@ -1800,17 +1800,9 @@ bus_context_check_security_policy (BusContext *context,
71 /* See if limits on size have been exceeded */
72 - if (proposed_recipient &&
73 - ((dbus_connection_get_outgoing_size (proposed_recipient) > context->limits.max_outgoing_bytes) ||
74 - (dbus_connection_get_outgoing_unix_fds (proposed_recipient) > context->limits.max_outgoing_unix_fds)))
76 - complain_about_message (context, DBUS_ERROR_LIMITS_EXCEEDED,
77 - "Rejected: destination has a full message queue",
78 - 0, message, sender, proposed_recipient, requested_reply, TRUE, NULL,
80 - _dbus_verbose ("security policy disallowing message due to full message queue\n");
81 + if (!bus_context_check_recipient_message_limits(context, proposed_recipient, sender, message,
82 + requested_reply, error))
83 return BUS_RESULT_FALSE;
86 /* Record that we will allow a reply here in the future (don't
87 * bother if the recipient is the bus or this is an eavesdropping
88 @@ -1869,3 +1861,41 @@ bus_context_check_all_watches (BusContext *context)
89 _dbus_server_toggle_all_watches (server, enabled);
94 +bus_context_complain_about_message (BusContext *context,
95 + const char *error_name,
96 + const char *complaint,
98 + DBusMessage *message,
99 + DBusConnection *sender,
100 + DBusConnection *proposed_recipient,
101 + dbus_bool_t requested_reply,
103 + const char *privilege,
106 + complain_about_message(context, error_name, complaint, matched_rules, message, sender,
107 + proposed_recipient, requested_reply, log, privilege, error);
110 +dbus_bool_t bus_context_check_recipient_message_limits (BusContext *context,
111 + DBusConnection *recipient,
112 + DBusConnection *sender,
113 + DBusMessage *message,
114 + dbus_bool_t requested_reply,
118 + ((dbus_connection_get_outgoing_size (recipient) > context->limits.max_outgoing_bytes) ||
119 + (dbus_connection_get_outgoing_unix_fds (recipient) > context->limits.max_outgoing_unix_fds)))
121 + complain_about_message (context, DBUS_ERROR_LIMITS_EXCEEDED,
122 + "Rejected: destination has a full message queue",
123 + 0, message, sender, recipient, requested_reply, TRUE, NULL,
125 + _dbus_verbose ("security policy disallowing message due to full message queue\n");
130 diff --git a/bus/bus.h b/bus/bus.h
131 index 82c32c8..1b08f7c 100644
134 @@ -164,4 +164,23 @@ BusResult bus_context_check_security_policy (BusContext
135 BusDeferredMessage **deferred_message);
136 void bus_context_check_all_watches (BusContext *context);
138 +dbus_bool_t bus_context_check_recipient_message_limits (BusContext *context,
139 + DBusConnection *recipient,
140 + DBusConnection *sender,
141 + DBusMessage *message,
142 + dbus_bool_t requested_reply,
144 +void bus_context_complain_about_message (BusContext *context,
145 + const char *error_name,
146 + const char *complaint,
148 + DBusMessage *message,
149 + DBusConnection *sender,
150 + DBusConnection *proposed_recipient,
151 + dbus_bool_t requested_reply,
153 + const char *privilege,
157 #endif /* BUS_BUS_H */
158 diff --git a/bus/check.c b/bus/check.c
159 index 4b8a699..f3d283f 100644
162 @@ -49,6 +49,9 @@ typedef struct BusDeferredMessage
163 DBusConnection *sender;
164 DBusConnection *proposed_recipient;
165 DBusConnection *addressed_recipient;
166 + dbus_bool_t requested_reply;
168 + const char *privilege;
169 dbus_bool_t full_dispatch;
170 BusDeferredMessageStatus status;
172 @@ -135,6 +138,89 @@ bus_check_enable_dispatch_callback (BusDeferredMessage *deferred_message,
173 _dbus_connection_enable_dispatch(deferred_message->sender);
177 +bus_check_queued_message_reply_callback (BusDeferredMessage *deferred_message,
182 + _dbus_verbose("bus_check_queued_message_reply_callback called message=%p\n", deferred_message);
184 + if (!bus_connection_is_active(deferred_message->proposed_recipient))
187 + status = deferred_message->status;
189 + deferred_message->status = 0; /* mark message as not waiting for response */
190 + deferred_message->response = result;
193 + * If send rule allows us to send message we still need to check receive rules.
195 + if ((status & BUS_DEFERRED_MESSAGE_CHECK_SEND) && (result == BUS_RESULT_TRUE))
198 + BusContext *context;
199 + BusRegistry *registry;
200 + BusClientPolicy *recipient_policy;
201 + BusDeferredMessage *deferred_message_receive;
203 + context = bus_connection_get_context(deferred_message->proposed_recipient);
204 + registry = bus_context_get_registry(context);
205 + recipient_policy = bus_connection_get_policy(deferred_message->proposed_recipient);
207 + deferred_message->response = bus_client_policy_check_can_receive(recipient_policy, registry,
208 + deferred_message->requested_reply, deferred_message->sender,
209 + deferred_message->addressed_recipient, deferred_message->proposed_recipient, deferred_message->message,
210 + &toggles, NULL, &deferred_message_receive);
211 + if (deferred_message->response == BUS_RESULT_LATER)
213 + /* replace deferred message associated with send check with the one associated with
215 + if (!bus_deferred_message_replace(deferred_message, deferred_message_receive))
217 + /* failed to replace deferred message (due to oom). Set it to rejected */
218 + deferred_message->response = BUS_RESULT_FALSE;
223 + bus_connection_dispatch_deferred(deferred_message->proposed_recipient);
227 +queue_deferred_message_cancel_transaction_hook (void *data)
229 + BusDeferredMessage *deferred_message = (BusDeferredMessage *)data;
230 + bus_connection_remove_deferred_message(deferred_message->proposed_recipient, deferred_message);
235 +bus_deferred_message_queue_at_recipient (BusDeferredMessage *deferred_message,
236 + BusTransaction *transaction,
237 + dbus_bool_t full_dispatch,
238 + dbus_bool_t prepend)
240 + _dbus_assert(deferred_message != NULL);
241 + _dbus_assert(deferred_message->proposed_recipient != NULL);
243 + if (!bus_connection_queue_deferred_message(deferred_message->proposed_recipient,
244 + deferred_message, prepend))
247 + if (!bus_transaction_add_cancel_hook(transaction, queue_deferred_message_cancel_transaction_hook,
248 + deferred_message, NULL))
250 + bus_connection_remove_deferred_message(deferred_message->proposed_recipient, deferred_message);
253 + deferred_message->response_callback = bus_check_queued_message_reply_callback;
254 + deferred_message->full_dispatch = full_dispatch;
260 deferred_message_free_function(void *data)
262 @@ -159,6 +245,20 @@ bus_deferred_message_disable_sender (BusDeferredMessage *deferred_message)
263 deferred_message->response_callback = bus_check_enable_dispatch_callback;
267 +bus_deferred_message_set_policy_check_info (BusDeferredMessage *deferred_message,
268 + dbus_bool_t requested_reply,
270 + const char *privilege)
272 + _dbus_assert(deferred_message != NULL);
274 + deferred_message->requested_reply = requested_reply;
275 + deferred_message->matched_rules = matched_rules;
276 + deferred_message->privilege = privilege;
280 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
281 BusResult (*bus_check_test_override) (DBusConnection *connection,
282 const char *privilege);
283 @@ -259,6 +359,9 @@ BusDeferredMessage *bus_deferred_message_new (DBusMessage *message,
284 deferred_message->addressed_recipient = addressed_recipient != NULL ? dbus_connection_ref(addressed_recipient) : NULL;
285 deferred_message->proposed_recipient = proposed_recipient != NULL ? dbus_connection_ref(proposed_recipient) : NULL;
286 deferred_message->message = dbus_message_ref(message);
287 + deferred_message->requested_reply = FALSE;
288 + deferred_message->matched_rules = 0;
289 + deferred_message->privilege = NULL;
290 deferred_message->response = response;
291 deferred_message->status = 0;
292 deferred_message->full_dispatch = FALSE;
293 @@ -295,12 +398,215 @@ bus_deferred_message_unref (BusDeferredMessage *deferred_message)
298 +bus_deferred_message_check_message_limits (BusDeferredMessage *deferred_message, DBusError *error)
300 + BusContext *context = bus_connection_get_context(deferred_message->proposed_recipient);
302 + return bus_context_check_recipient_message_limits(context, deferred_message->proposed_recipient,
303 + deferred_message->sender, deferred_message->message, deferred_message->requested_reply,
308 +bus_deferred_message_expect_method_reply(BusDeferredMessage *deferred_message, BusTransaction *transaction, DBusError *error)
310 + int type = dbus_message_get_type(deferred_message->message);
311 + if (type == DBUS_MESSAGE_TYPE_METHOD_CALL &&
312 + deferred_message->sender &&
313 + deferred_message->addressed_recipient &&
314 + deferred_message->addressed_recipient == deferred_message->proposed_recipient && /* not eavesdropping */
315 + !bus_connections_expect_reply (bus_connection_get_connections (deferred_message->sender),
317 + deferred_message->sender, deferred_message->addressed_recipient,
318 + deferred_message->message, error))
320 + _dbus_verbose ("Failed to record reply expectation or problem with the message expecting a reply\n");
327 +bus_deferred_message_create_error(BusDeferredMessage *deferred_message,
328 + const char *error_message, DBusError *error)
330 + BusContext *context;
331 + _dbus_assert (deferred_message->status == 0 && deferred_message->response == BUS_RESULT_FALSE);
333 + if (deferred_message->sender == NULL)
334 + return; /* error won't be sent to bus driver anyway */
336 + context = bus_connection_get_context(deferred_message->sender);
337 + bus_context_complain_about_message(context, DBUS_ERROR_ACCESS_DENIED, "Rejected message",
338 + deferred_message->matched_rules, deferred_message->message, deferred_message->sender,
339 + deferred_message->proposed_recipient, deferred_message->requested_reply, FALSE,
340 + deferred_message->privilege, error);
344 +bus_deferred_message_dispatch (BusDeferredMessage *deferred_message)
346 + BusContext *context = bus_connection_get_context (deferred_message->proposed_recipient);
347 + BusTransaction *transaction = bus_transaction_new (context);
348 + BusResult result = BUS_RESULT_TRUE;
351 + if (transaction == NULL)
353 + return BUS_RESULT_FALSE;
356 + dbus_error_init(&error);
358 + if (!deferred_message->full_dispatch)
360 + result = deferred_message->response;
361 + if (result == BUS_RESULT_TRUE)
363 + if (!bus_context_check_recipient_message_limits(context, deferred_message->proposed_recipient,
364 + deferred_message->sender, deferred_message->message, deferred_message->requested_reply, &error))
365 + result = BUS_RESULT_FALSE;
367 + else if (result == BUS_RESULT_LATER)
369 + BusDeferredMessage *deferred_message2;
370 + result = bus_context_check_security_policy (context, transaction,
371 + deferred_message->sender,
372 + deferred_message->addressed_recipient,
373 + deferred_message->proposed_recipient,
374 + deferred_message->message, NULL, NULL,
375 + &deferred_message2);
377 + if (result == BUS_RESULT_LATER)
379 + /* prepend at recipient */
380 + if (!bus_deferred_message_queue_at_recipient(deferred_message2, transaction,
382 + result = BUS_RESULT_FALSE;
386 + /* silently drop messages on access denial */
387 + if (result == BUS_RESULT_TRUE)
389 + if (!bus_transaction_send (transaction, deferred_message->proposed_recipient, deferred_message->message, TRUE))
390 + result = BUS_RESULT_FALSE;
393 + bus_transaction_execute_and_free(transaction);
398 + /* do not attempt to send message if sender has disconnected */
399 + if (deferred_message->sender != NULL && !bus_connection_is_active(deferred_message->sender))
401 + bus_transaction_cancel_and_free(transaction);
402 + result = BUS_RESULT_FALSE;
406 + result = bus_dispatch_matches(transaction, deferred_message->sender,
407 + deferred_message->addressed_recipient, deferred_message->message, deferred_message, &error);
409 + if (result == BUS_RESULT_LATER)
411 + /* Message deferring was already done in bus_dispatch_matches */
412 + bus_transaction_cancel_and_free(transaction);
416 + /* this part is a copy & paste from bus_dispatch function. Probably can be moved to a function */
417 + if (dbus_error_is_set (&error))
419 + if (!dbus_connection_get_is_connected (deferred_message->sender))
421 + /* If we disconnected it, we won't bother to send it any error
424 + _dbus_verbose ("Not sending error to connection we disconnected\n");
426 + else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
428 + bus_connection_send_oom_error (deferred_message->sender, deferred_message->message);
430 + /* cancel transaction due to OOM */
431 + if (transaction != NULL)
433 + bus_transaction_cancel_and_free (transaction);
434 + transaction = NULL;
439 + /* Try to send the real error, if no mem to do that, send
442 + _dbus_assert (transaction != NULL);
443 + if (!bus_transaction_send_error_reply (transaction, deferred_message->sender,
444 + &error, deferred_message->message))
446 + bus_connection_send_oom_error (deferred_message->sender, deferred_message->message);
448 + /* cancel transaction due to OOM */
449 + if (transaction != NULL)
451 + bus_transaction_cancel_and_free (transaction);
452 + transaction = NULL;
458 + if (transaction != NULL)
460 + bus_transaction_execute_and_free (transaction);
464 + dbus_error_free(&error);
470 +bus_deferred_message_replace (BusDeferredMessage *old_message, BusDeferredMessage *new_message)
472 + if (bus_connection_replace_deferred_message(old_message->proposed_recipient,
473 + old_message, new_message))
475 + new_message->response_callback = old_message->response_callback;
476 + new_message->full_dispatch = old_message->full_dispatch;
483 +bus_deferred_message_waits_for_check(BusDeferredMessage *deferred_message)
485 + return deferred_message->status != 0;
489 +bus_deferred_message_get_recipient(BusDeferredMessage *deferred_message)
491 + return deferred_message->proposed_recipient;
494 BusDeferredMessageStatus
495 bus_deferred_message_get_status (BusDeferredMessage *deferred_message)
497 return deferred_message->status;
501 +bus_deferred_message_get_response (BusDeferredMessage *deferred_message)
503 + return deferred_message->response;
507 bus_deferred_message_response_received (BusDeferredMessage *deferred_message,
509 @@ -310,3 +616,4 @@ bus_deferred_message_response_received (BusDeferredMessage *deferred_message,
510 deferred_message->response_callback(deferred_message, result);
514 diff --git a/bus/check.h b/bus/check.h
515 index d177549..9c13c18 100644
518 @@ -64,12 +64,37 @@ BusDeferredMessage *bus_deferred_message_new (DBusMessage *messag
520 BusDeferredMessage *bus_deferred_message_ref (BusDeferredMessage *deferred_message);
521 void bus_deferred_message_unref (BusDeferredMessage *deferred_message);
522 +BusResult bus_deferred_message_dispatch (BusDeferredMessage *deferred_message);
523 +dbus_bool_t bus_deferred_message_waits_for_check (BusDeferredMessage *deferred_message);
524 +DBusConnection *bus_deferred_message_get_recipient (BusDeferredMessage *deferred_message);
525 void bus_deferred_message_response_received (BusDeferredMessage *deferred_message,
527 +dbus_bool_t bus_deferred_message_queue_at_recipient (BusDeferredMessage *deferred_message,
528 + BusTransaction *transaction,
529 + dbus_bool_t full_dispatch,
530 + dbus_bool_t prepend);
531 +dbus_bool_t bus_deferred_message_replace (BusDeferredMessage *old_message,
532 + BusDeferredMessage *new_message);
533 void bus_deferred_message_disable_sender (BusDeferredMessage *deferred_message);
534 +BusResult bus_deferred_message_get_response (BusDeferredMessage *deferred_message);
536 BusDeferredMessageStatus bus_deferred_message_get_status (BusDeferredMessage *deferred_message);
539 +dbus_bool_t bus_deferred_message_expect_method_reply (BusDeferredMessage *deferred_message,
540 + BusTransaction *transaction,
542 +void bus_deferred_message_create_error (BusDeferredMessage *deferred_message,
543 + const char *error_message,
545 +void bus_deferred_message_set_policy_check_info (BusDeferredMessage *deferred_message,
546 + dbus_bool_t requested_reply,
548 + const char *privilege);
549 +dbus_bool_t bus_deferred_message_check_message_limits (BusDeferredMessage *deferred_message,
553 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
554 extern BusResult (*bus_check_test_override) (DBusConnection *connection,
555 const char *privilege);
556 diff --git a/bus/connection.c b/bus/connection.c
557 index b348d42..ee93384 100644
558 --- a/bus/connection.c
559 +++ b/bus/connection.c
561 #include "expirelist.h"
563 #include "apparmor.h"
565 #include <dbus/dbus-list.h>
566 #include <dbus/dbus-hash.h>
567 #include <dbus/dbus-timeout.h>
568 #include <dbus/dbus-connection-internal.h>
569 #include <dbus/dbus-internals.h>
570 +#include <dbus/dbus-message-internal.h>
571 #ifdef DBUS_ENABLE_CYNARA
573 #include <cynara-session.h>
574 @@ -102,6 +104,7 @@ typedef struct
575 DBusMessage *oom_message;
576 DBusPreallocatedSend *oom_preallocated;
577 BusClientPolicy *policy;
578 + DBusList *deferred_messages; /**< Queue of messages deferred due to pending policy check */
580 char *cached_loginfo_string;
581 BusSELinuxID *selinux_id;
582 @@ -268,6 +271,8 @@ bus_connection_disconnected (DBusConnection *connection)
583 bus_transaction_execute_and_free (transaction);
586 + bus_connection_clear_deferred_messages(connection);
588 bus_dispatch_remove_connection (connection);
590 /* no more watching */
591 @@ -2307,7 +2312,7 @@ bus_transaction_capture (BusTransaction *transaction,
593 DBusConnection *recipient = link->data;
595 - if (!bus_transaction_send (transaction, recipient, message))
596 + if (!bus_transaction_send (transaction, recipient, message, FALSE))
600 @@ -2361,6 +2366,7 @@ bus_transaction_send_from_driver (BusTransaction *transaction,
602 DBusError error = DBUS_ERROR_INIT;
604 + BusDeferredMessage *deferred_message;
606 /* We have to set the sender to the driver, and have
607 * to check security policy since it was not done in
608 @@ -2401,7 +2407,7 @@ bus_transaction_send_from_driver (BusTransaction *transaction,
609 res = bus_context_check_security_policy (bus_transaction_get_context (transaction),
611 NULL, connection, connection, message, NULL,
613 + &error, &deferred_message);
614 if (res == BUS_RESULT_FALSE)
616 if (!bus_transaction_capture_error_reply (transaction, connection,
617 @@ -2419,18 +2425,20 @@ bus_transaction_send_from_driver (BusTransaction *transaction,
619 else if (res == BUS_RESULT_LATER)
621 - _dbus_verbose ("Cannot delay sending message from bus driver, dropping it\n");
622 dbus_error_free (&error);
624 + if (!bus_deferred_message_queue_at_recipient(deferred_message, transaction, FALSE, FALSE))
626 + return TRUE; /* pretend to have sent it */
629 - return bus_transaction_send (transaction, connection, message);
630 + return bus_transaction_send (transaction, connection, message, FALSE);
634 bus_transaction_send (BusTransaction *transaction,
635 DBusConnection *connection,
636 - DBusMessage *message)
637 + DBusMessage *message,
638 + dbus_bool_t deferred_dispatch)
640 MessageToSend *to_send;
641 BusConnectionData *d;
642 @@ -2456,7 +2464,28 @@ bus_transaction_send (BusTransaction *transaction,
644 d = BUS_CONNECTION_DATA (connection);
645 _dbus_assert (d != NULL);
648 + if (!deferred_dispatch && d->deferred_messages != NULL)
650 + BusDeferredMessage *deferred_message;
651 + dbus_bool_t success;
652 + /* sender and addressed recipient are not required at this point as we only need to send message
653 + * to a single recipient without performing policy check. */
654 + deferred_message = bus_deferred_message_new (message,
659 + if (deferred_message == NULL)
662 + success = bus_deferred_message_queue_at_recipient(deferred_message, transaction,
664 + bus_deferred_message_unref(deferred_message);
669 to_send = dbus_new (MessageToSend, 1);
672 @@ -2708,6 +2737,131 @@ bus_transaction_add_cancel_hook (BusTransaction *transaction,
677 +bus_connection_dispatch_deferred (DBusConnection *connection)
679 + BusDeferredMessage *message;
681 + _dbus_return_if_fail (connection != NULL);
683 + while ((message = bus_connection_pop_deferred_message(connection)) != NULL)
685 + bus_deferred_message_dispatch(message);
686 + bus_deferred_message_unref(message);
691 +bus_connection_has_deferred_messages (DBusConnection *connection)
693 + BusConnectionData *d = BUS_CONNECTION_DATA(connection);
694 + return d->deferred_messages != NULL ? TRUE : FALSE;
698 +bus_connection_queue_deferred_message (DBusConnection *connection,
699 + BusDeferredMessage *message,
700 + dbus_bool_t prepend)
702 + BusConnectionData *d = BUS_CONNECTION_DATA(connection);
703 + dbus_bool_t success;
705 + success = _dbus_list_prepend(&d->deferred_messages, message);
707 + success = _dbus_list_append(&d->deferred_messages, message);
711 + bus_deferred_message_ref(message);
719 +bus_connection_replace_deferred_message (DBusConnection *connection,
720 + BusDeferredMessage *oldMessage,
721 + BusDeferredMessage *newMessage)
724 + BusConnectionData *d = BUS_CONNECTION_DATA(connection);
726 + link = _dbus_list_find_first(&d->deferred_messages, oldMessage);
730 + if (!_dbus_list_insert_after(&d->deferred_messages, link, newMessage))
733 + bus_deferred_message_ref(newMessage);
734 + _dbus_list_remove_link(&d->deferred_messages, link);
735 + bus_deferred_message_unref(oldMessage);
739 +BusDeferredMessage *
740 +bus_connection_pop_deferred_message (DBusConnection *connection)
743 + BusDeferredMessage *message;
744 + BusConnectionData *d = BUS_CONNECTION_DATA(connection);
746 + link =_dbus_list_get_first_link(&d->deferred_messages);
749 + message = link->data;
750 + if (!bus_deferred_message_waits_for_check(message))
752 + _dbus_list_remove_link(&d->deferred_messages, link);
761 +bus_connection_putback_deferred_message (DBusConnection *connection, BusDeferredMessage *message)
763 + BusConnectionData *d = BUS_CONNECTION_DATA(connection);
764 + if (_dbus_list_prepend(&d->deferred_messages, message))
772 +bus_connection_clear_deferred_messages (DBusConnection *connection)
774 + BusConnectionData *d = BUS_CONNECTION_DATA(connection);
777 + BusDeferredMessage *message;
779 + link =_dbus_list_get_first_link(&d->deferred_messages);
780 + while (link != NULL)
782 + next = _dbus_list_get_next_link (&d->deferred_messages, link);
783 + message = link->data;
785 + bus_deferred_message_unref(message);
786 + _dbus_list_remove_link(&d->deferred_messages, link);
793 +bus_connection_remove_deferred_message (DBusConnection *connection,
794 + BusDeferredMessage *message)
796 + BusConnectionData *d = BUS_CONNECTION_DATA(connection);
797 + if (_dbus_list_remove(&d->deferred_messages, message))
798 + bus_deferred_message_unref(message);
802 bus_connections_get_n_active (BusConnections *connections)
804 diff --git a/bus/connection.h b/bus/connection.h
805 index 71078ea..97dae96 100644
806 --- a/bus/connection.h
807 +++ b/bus/connection.h
808 @@ -85,6 +85,22 @@ dbus_bool_t bus_connection_preallocate_oom_error (DBusConnection *connection);
809 void bus_connection_send_oom_error (DBusConnection *connection,
810 DBusMessage *in_reply_to);
812 +dbus_bool_t bus_connection_has_deferred_messages (DBusConnection *connection);
813 +dbus_bool_t bus_connection_queue_deferred_message (DBusConnection *connection,
814 + BusDeferredMessage *message,
815 + dbus_bool_t prepend);
816 +BusDeferredMessage *bus_connection_pop_deferred_message (DBusConnection *connection);
817 +dbus_bool_t bus_connection_putback_deferred_message (DBusConnection *connection,
818 + BusDeferredMessage *message);
819 +void bus_connection_remove_deferred_message (DBusConnection *connection,
820 + BusDeferredMessage *message);
821 +dbus_bool_t bus_connection_replace_deferred_message (DBusConnection *connection,
822 + BusDeferredMessage *oldMessage,
823 + BusDeferredMessage *newMessage);
824 +void bus_connection_dispatch_deferred (DBusConnection *connection);
825 +void bus_connection_clear_deferred_messages (DBusConnection *connection);
828 /* called by signals.c */
829 dbus_bool_t bus_connection_add_match_rule (DBusConnection *connection,
831 @@ -137,7 +153,8 @@ BusTransaction* bus_transaction_new (BusContext *
832 BusContext* bus_transaction_get_context (BusTransaction *transaction);
833 dbus_bool_t bus_transaction_send (BusTransaction *transaction,
834 DBusConnection *connection,
835 - DBusMessage *message);
836 + DBusMessage *message,
837 + dbus_bool_t deferred_dispatch);
838 dbus_bool_t bus_transaction_capture (BusTransaction *transaction,
839 DBusConnection *connection,
840 DBusConnection *addressed_recipient,
841 diff --git a/bus/dispatch.c b/bus/dispatch.c
842 index 50a22a3..7d30ce4 100644
849 +#include "dispatch.h"
851 #include <dbus/dbus-internals.h>
852 #include <dbus/dbus-connection-internal.h>
853 @@ -77,7 +78,7 @@ send_one_message (DBusConnection *connection,
857 - if (result != BUS_RESULT_TRUE)
858 + if (result == BUS_RESULT_FALSE)
860 if (!bus_transaction_capture_error_reply (transaction, sender,
861 &stack_error, message))
862 @@ -112,9 +113,19 @@ send_one_message (DBusConnection *connection,
863 return TRUE; /* don't send it but don't return an error either */
866 + if (result == BUS_RESULT_LATER)
868 + if (!bus_deferred_message_queue_at_recipient(deferred_message, transaction, FALSE, FALSE))
870 + BUS_SET_OOM (error);
873 + return TRUE; /* pretend to have sent it */
876 if (!bus_transaction_send (transaction,
883 @@ -124,11 +135,12 @@ send_one_message (DBusConnection *connection,
887 -bus_dispatch_matches (BusTransaction *transaction,
888 - DBusConnection *sender,
889 - DBusConnection *addressed_recipient,
890 - DBusMessage *message,
892 +bus_dispatch_matches (BusTransaction *transaction,
893 + DBusConnection *sender,
894 + DBusConnection *addressed_recipient,
895 + DBusMessage *message,
896 + BusDeferredMessage *dispatched_deferred_message,
900 BusConnections *connections;
901 @@ -137,7 +149,6 @@ bus_dispatch_matches (BusTransaction *transaction,
904 BusDeferredMessage *deferred_message;
907 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
909 @@ -153,16 +164,80 @@ bus_dispatch_matches (BusTransaction *transaction,
910 /* First, send the message to the addressed_recipient, if there is one. */
911 if (addressed_recipient != NULL)
913 - res = bus_context_check_security_policy (context, transaction,
915 + /* To maintain message order message needs to be appended at the recipient if there are already
916 + * deferred messages and we are not doing deferred dispatch
918 + if (dispatched_deferred_message == NULL && bus_connection_has_deferred_messages(addressed_recipient))
920 + deferred_message = bus_deferred_message_new(message, sender,
921 + addressed_recipient, addressed_recipient, BUS_RESULT_LATER);
923 + if (deferred_message == NULL)
925 + BUS_SET_OOM(error);
926 + return BUS_RESULT_FALSE;
929 + if (!bus_deferred_message_queue_at_recipient(deferred_message, transaction, TRUE, FALSE))
931 + bus_deferred_message_unref(deferred_message);
932 + BUS_SET_OOM(error);
933 + return BUS_RESULT_FALSE;
936 + bus_deferred_message_unref(deferred_message);
937 + return BUS_RESULT_TRUE; /* pretend to have sent it */
940 + if (dispatched_deferred_message != NULL)
942 + result = bus_deferred_message_get_response(dispatched_deferred_message);
943 + if (result == BUS_RESULT_TRUE)
945 + /* if we know the result of policy check we still need to check if message limits
946 + * are not exceeded. It is also required to add entry in expected replies list if
947 + * this is a method call
949 + if (!bus_deferred_message_check_message_limits(dispatched_deferred_message, error))
950 + return BUS_RESULT_FALSE;
952 + if (!bus_deferred_message_expect_method_reply(dispatched_deferred_message, transaction, error))
953 + return BUS_RESULT_FALSE;
955 + else if (result == BUS_RESULT_FALSE)
957 + bus_deferred_message_create_error(dispatched_deferred_message, "Rejected message", error);
958 + return BUS_RESULT_FALSE;
962 + result = BUS_RESULT_LATER;
964 + if (result == BUS_RESULT_LATER)
965 + result = bus_context_check_security_policy (context, transaction,
966 sender, addressed_recipient,
968 message, NULL, error,
970 - if (res == BUS_RESULT_FALSE)
972 + if (result == BUS_RESULT_FALSE)
973 return BUS_RESULT_FALSE;
974 - else if (res == BUS_RESULT_LATER)
975 + else if (result == BUS_RESULT_LATER)
977 BusDeferredMessageStatus status;
979 + if (dispatched_deferred_message != NULL)
981 + /* for deferred dispatch prepend message at the recipient */
982 + if (!bus_deferred_message_queue_at_recipient(deferred_message, transaction, TRUE, TRUE))
984 + BUS_SET_OOM(error);
985 + return BUS_RESULT_FALSE;
987 + return BUS_RESULT_TRUE; /* pretend to have sent it */
990 status = bus_deferred_message_get_status(deferred_message);
992 if (status & BUS_DEFERRED_MESSAGE_CHECK_SEND)
993 @@ -173,13 +248,18 @@ bus_dispatch_matches (BusTransaction *transaction,
995 else if (status & BUS_DEFERRED_MESSAGE_CHECK_RECEIVE)
997 - dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
998 - "Rejecting message because time is needed to check security policy");
999 - return BUS_RESULT_FALSE;
1000 + /* receive rule result not available - queue message at the recipient */
1001 + if (!bus_deferred_message_queue_at_recipient(deferred_message, transaction, TRUE, FALSE))
1003 + BUS_SET_OOM(error);
1004 + return BUS_RESULT_FALSE;
1007 + return BUS_RESULT_TRUE; /* pretend to have sent it */
1011 - _dbus_verbose("deferred message has no status field set to send or receive unexpectedly\n");
1012 + _dbus_verbose("deferred message has no status field set unexpectedly\n");
1013 return BUS_RESULT_FALSE;
1016 @@ -196,7 +276,8 @@ bus_dispatch_matches (BusTransaction *transaction,
1019 /* Dispatch the message */
1020 - if (!bus_transaction_send (transaction, addressed_recipient, message))
1021 + if (!bus_transaction_send(transaction, addressed_recipient, message,
1022 + dispatched_deferred_message != NULL ? TRUE : FALSE))
1024 BUS_SET_OOM (error);
1025 return BUS_RESULT_FALSE;
1026 @@ -534,7 +615,7 @@ bus_dispatch (DBusConnection *connection,
1029 if (BUS_RESULT_LATER == bus_dispatch_matches (transaction, connection, addressed_recipient,
1031 + message, NULL, &error))
1033 /* Roll back and dispatch the message once the policy result is available */
1034 bus_transaction_cancel_and_free (transaction);
1035 diff --git a/bus/dispatch.h b/bus/dispatch.h
1036 index afba6a2..f6102e8 100644
1037 --- a/bus/dispatch.h
1038 +++ b/bus/dispatch.h
1041 dbus_bool_t bus_dispatch_add_connection (DBusConnection *connection);
1042 void bus_dispatch_remove_connection (DBusConnection *connection);
1043 -BusResult bus_dispatch_matches (BusTransaction *transaction,
1044 - DBusConnection *sender,
1045 - DBusConnection *recipient,
1046 - DBusMessage *message,
1047 - DBusError *error);
1048 +BusResult bus_dispatch_matches (BusTransaction *transaction,
1049 + DBusConnection *sender,
1050 + DBusConnection *recipient,
1051 + DBusMessage *message,
1052 + BusDeferredMessage *dispatched_deferred_message,
1053 + DBusError *error);
1055 #endif /* BUS_DISPATCH_H */
1056 diff --git a/bus/driver.c b/bus/driver.c
1057 index f414f64..d89a658 100644
1060 @@ -254,7 +254,7 @@ bus_driver_send_service_owner_changed (const char *service_name,
1061 if (!bus_transaction_capture (transaction, NULL, NULL, message))
1064 - res = bus_dispatch_matches (transaction, NULL, NULL, message, error);
1065 + res = bus_dispatch_matches (transaction, NULL, NULL, message, NULL, error);
1066 if (res == BUS_RESULT_TRUE)
1069 diff --git a/bus/policy.c b/bus/policy.c
1070 index 7de92c6..483cc97 100644
1073 @@ -1122,6 +1122,9 @@ bus_client_policy_check_can_send (DBusConnection *sender,
1075 result = bus_check_privilege(check, message, sender, addressed_recipient, receiver,
1076 privilege, BUS_DEFERRED_MESSAGE_CHECK_SEND, deferred_message);
1077 + if (result == BUS_RESULT_LATER && deferred_message != NULL)
1078 + bus_deferred_message_set_policy_check_info(*deferred_message, requested_reply,
1079 + *toggles, privilege);
1083 @@ -1372,6 +1375,9 @@ bus_client_policy_check_can_receive (BusClientPolicy *policy,
1085 result = bus_check_privilege(check, message, sender, addressed_recipient, proposed_recipient,
1086 privilege, BUS_DEFERRED_MESSAGE_CHECK_RECEIVE, deferred_message);
1087 + if (result == BUS_RESULT_LATER && deferred_message != NULL)
1088 + bus_deferred_message_set_policy_check_info(*deferred_message, requested_reply,
1089 + *toggles, privilege);