« back to all changes in this revision
Viewing changes to bus/dispatch.c
- browse files at revision 89
- compare with another revision
- download diff
- download tarball
- view history from revision 89
- Committer: Bazaar Package Importer
- Author(s): Jonathan Riddell
- Date: 2010-09-27 13:06:32 UTC
- mfrom: (1.1.23 upstream)
- Revision ID: james.westby@ubuntu.com-20100927130632-bqs145trvchd2lmf
Tags: 1.4.0-0ubuntu1
* New upstream release
- Fixes https://bugs.freedesktop.org/show_bug.cgi?id=17754 Race condition in protected_change_timeout
- Requested by various upstream KDE developers http://lists.kde.org/?t=128514970000004&r=1&w=2
- Fixes https://bugs.freedesktop.org/show_bug.cgi?id=17754 Race condition in protected_change_timeout
- Requested by various upstream KDE developers http://lists.kde.org/?t=128514970000004&r=1&w=2
- files added:
- README.windbus
- files removed:
- .pc/11-589662-reload-kqueue.patch
- .pc/11-589662-reload-kqueue.patch/bus
- files modified:
- .pc/00_dbus-quiesce-startup-errors.patch/bus/config-parser.c
added
removed
bus/dispatch.c
6
6
* Copyright (C) 2004 Imendio HB
7
7
*
8
8
* Licensed under the Academic Free License version 2.1
9
*
9
*
10
10
* This program is free software; you can redistribute it and/or modify
11
11
* it under the terms of the GNU General Public License as published by
12
12
* the Free Software Foundation; either version 2 of the License, or
16
16
* but WITHOUT ANY WARRANTY; without even the implied warranty of
17
17
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18
18
* GNU General Public License for more details.
19
*
19
*
20
20
* You should have received a copy of the GNU General Public License
21
21
* along with this program; if not, write to the Free Software
22
22
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
23
*
24
24
*/
25
25
26
#include <config.h>
26
27
#include "dispatch.h"
27
28
#include "connection.h"
28
29
#include "driver.h"
35
36
#include <dbus/dbus-internals.h>
36
37
#include <string.h>
37
38
39
#ifdef HAVE_UNIX_FD_PASSING
40
#include <dbus/dbus-sysdeps-unix.h>
41
#include <unistd.h>
42
#endif
43
44
#ifndef TEST_CONNECTION
45
/*
46
TODO autotools:
47
move to build system as already done for cmake
48
*/
49
#ifdef DBUS_UNIX
50
#define TEST_CONNECTION "debug-pipe:name=test-server"
51
#else
52
#define TEST_CONNECTION "tcp:host=localhost,port=1234"
53
#endif
54
#endif
55
38
56
static dbus_bool_t
39
57
send_one_message (DBusConnection *connection,
40
58
BusContext *context,
51
69
message,
52
70
NULL))
53
71
return TRUE; /* silently don't send it */
54
72
73
if (dbus_message_contains_unix_fds(message) &&
74
!dbus_connection_can_send_type(connection, DBUS_TYPE_UNIX_FD))
75
return TRUE; /* silently don't send it */
76
55
77
if (!bus_transaction_send (transaction,
56
78
connection,
57
79
message))
97
119
message, error))
98
120
return FALSE;
99
121
122
if (dbus_message_contains_unix_fds (message) &&
123
!dbus_connection_can_send_type (addressed_recipient,
124
DBUS_TYPE_UNIX_FD))
125
{
126
dbus_set_error (error,
127
DBUS_ERROR_NOT_SUPPORTED,
128
"Tried to send message with Unix file descriptors"
129
"to a client that doesn't support that.");
130
return FALSE;
131
}
132
100
133
/* Dispatch the message */
101
134
if (!bus_transaction_send (transaction, addressed_recipient, message))
102
135
{
134
167
}
135
168
136
169
_dbus_list_clear (&recipients);
137
170
138
171
if (dbus_error_is_set (&tmp_error))
139
172
{
140
173
dbus_move_error (&tmp_error, error);
154
187
BusContext *context;
155
188
DBusHandlerResult result;
156
189
DBusConnection *addressed_recipient;
157
190
158
191
result = DBUS_HANDLER_RESULT_HANDLED;
159
192
160
193
transaction = NULL;
161
194
addressed_recipient = NULL;
162
195
dbus_error_init (&error);
163
196
164
197
context = bus_connection_get_context (connection);
165
198
_dbus_assert (context != NULL);
166
199
167
200
/* If we can't even allocate an OOM error, we just go to sleep
168
201
* until we can.
169
202
*/
170
203
while (!bus_connection_preallocate_oom_error (connection))
171
204
_dbus_wait_for_memory ();
172
205
173
206
/* Ref connection in case we disconnect it at some point in here */
174
207
dbus_connection_ref (connection);
175
208
176
209
service_name = dbus_message_get_destination (message);
177
210
178
211
#ifdef DBUS_ENABLE_VERBOSE_MODE
182
215
interface_name = dbus_message_get_interface (message);
183
216
member_name = dbus_message_get_member (message);
184
217
error_name = dbus_message_get_error_name (message);
185
218
186
219
_dbus_verbose ("DISPATCH: %s %s %s to %s\n",
187
220
interface_name ? interface_name : "(no interface)",
188
221
member_name ? member_name : "(no member)",
190
223
service_name ? service_name : "peer");
191
224
}
192
225
#endif /* DBUS_ENABLE_VERBOSE_MODE */
193
226
194
227
/* If service_name is NULL, if it's a signal we send it to all
195
228
* connections with a match rule. If it's not a signal, there
196
229
* are some special cases here but mostly we just bail out.
214
247
goto out;
215
248
}
216
249
}
217
250
218
251
/* Create our transaction */
219
252
transaction = bus_transaction_new (context);
220
253
if (transaction == NULL)
222
255
BUS_SET_OOM (&error);
223
256
goto out;
224
257
}
225
258
226
259
/* Assign a sender to the message */
227
260
if (bus_connection_is_active (connection))
228
261
{
242
275
*/
243
276
service_name = dbus_message_get_destination (message);
244
277
}
245
278
246
279
if (service_name &&
247
280
strcmp (service_name, DBUS_SERVICE_DBUS) == 0) /* to bus driver */
248
281
{
270
303
BusRegistry *registry;
271
304
272
305
_dbus_assert (service_name != NULL);
273
306
274
307
registry = bus_connection_get_registry (connection);
275
308
276
309
_dbus_string_init_const (&service_string, service_name);
277
310
service = bus_registry_lookup (registry, &service_string);
278
311
292
325
_dbus_verbose ("bus_activation_activate_service() failed: %s\n", error.name);
293
326
goto out;
294
327
}
295
328
296
329
goto out;
297
330
}
298
331
else if (service == NULL)
316
349
*/
317
350
if (!bus_dispatch_matches (transaction, connection, addressed_recipient, message, &error))
318
351
goto out;
319
352
320
353
out:
321
354
if (dbus_error_is_set (&error))
322
355
{
348
381
&error, message))
349
382
{
350
383
bus_connection_send_oom_error (connection, message);
351
384
352
385
/* cancel transaction due to OOM */
353
386
if (transaction != NULL)
354
387
{
357
390
}
358
391
}
359
392
}
360
361
393
394
362
395
dbus_error_free (&error);
363
396
}
364
397
382
415
383
416
dbus_bool_t
384
417
bus_dispatch_add_connection (DBusConnection *connection)
385
{
418
{
386
419
if (!dbus_connection_add_filter (connection,
387
420
bus_dispatch_message_filter,
388
421
NULL, NULL))
389
422
return FALSE;
390
423
391
424
return TRUE;
392
425
}
393
426
424
457
const char *what_is_expected)
425
458
{
426
459
_dbus_verbose ("expecting: %s\n", what_is_expected);
427
460
428
461
while (dbus_connection_get_dispatch_status (connection) ==
429
462
DBUS_DISPATCH_COMPLETE &&
430
463
dbus_connection_get_is_connected (connection))
533
566
DBusError error;
534
567
const char *service_name, *old_owner, *new_owner;
535
568
536
if (d->expected_kind == SERVICE_CREATED
569
if (d->expected_kind == SERVICE_CREATED
537
570
&& connection == d->skip_connection)
538
571
return TRUE;
539
572
540
573
dbus_error_init (&error);
541
574
d->failed = TRUE;
542
575
543
576
message = pop_message_waiting_for_memory (connection);
544
577
if (message == NULL)
545
578
{
573
606
if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
574
607
{
575
608
dbus_error_free (&error);
576
_dbus_wait_for_memory ();
609
_dbus_wait_for_memory ();
577
610
goto reget_service_info_data;
578
611
}
579
612
else
599
632
goto out;
600
633
}
601
634
602
if (*service_name == ':' && new_owner[0]
635
if (*service_name == ':' && new_owner[0]
603
636
&& strcmp (service_name, new_owner) != 0)
604
637
{
605
638
_dbus_warn ("inconsistent ServiceOwnedChanged message (\"%s\" [ %s -> %s ])\n",
609
642
}
610
643
611
644
d->failed = FALSE;
612
645
613
646
out:
614
647
dbus_error_free (&error);
615
648
616
649
if (message)
617
650
dbus_message_unref (message);
618
651
629
662
CheckServiceOwnerChangedData socd;
630
663
631
664
_dbus_verbose ("killing connection %p\n", connection);
632
665
633
666
s = dbus_bus_get_unique_name (connection);
634
667
_dbus_assert (s != NULL);
635
668
637
670
_dbus_wait_for_memory ();
638
671
639
672
dbus_connection_ref (connection);
640
673
641
674
/* kick in the disconnect handler that unrefs the connection */
642
675
dbus_connection_close (connection);
643
676
644
677
bus_test_run_everything (context);
645
678
646
679
_dbus_assert (bus_test_client_listed (connection));
647
680
648
681
/* Run disconnect handler in test.c */
649
682
if (bus_connection_dispatch_one_message (connection))
650
683
_dbus_assert_not_reached ("something received on connection being killed other than the disconnect");
651
684
652
685
_dbus_assert (!dbus_connection_get_is_connected (connection));
653
686
dbus_connection_unref (connection);
654
687
connection = NULL;
655
688
_dbus_assert (!bus_test_client_listed (connection));
656
689
657
690
socd.expected_kind = SERVICE_DELETED;
658
691
socd.expected_service_name = base_service;
659
692
socd.failed = FALSE;
660
693
socd.skip_connection = NULL;
661
694
662
695
bus_test_clients_foreach (check_service_owner_changed_foreach,
663
696
&socd);
664
697
665
698
dbus_free (base_service);
666
699
667
700
if (socd.failed)
668
701
_dbus_assert_not_reached ("didn't get the expected NameOwnerChanged (deletion) messages");
669
702
670
703
if (!check_no_leftovers (context))
671
704
_dbus_assert_not_reached ("stuff left in message queues after disconnecting a client");
672
705
}
676
709
{
677
710
/* This kills the connection without expecting it to affect
678
711
* the rest of the bus.
679
*/
712
*/
680
713
_dbus_verbose ("Unchecked kill of connection %p\n", connection);
681
714
682
715
dbus_connection_ref (connection);
722
755
nmd.failed = FALSE;
723
756
bus_test_clients_foreach (check_no_messages_foreach,
724
757
&nmd);
725
758
726
759
if (nmd.failed)
727
760
{
728
_dbus_verbose ("%s: leftover message found\n",
729
_DBUS_FUNCTION_NAME);
761
_dbus_verbose ("leftover message found\n");
730
762
return FALSE;
731
763
}
732
764
else
756
788
name_message = NULL;
757
789
758
790
_dbus_verbose ("check_hello_message for %p\n", connection);
759
791
760
792
message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
761
793
DBUS_PATH_DBUS,
762
794
DBUS_INTERFACE_DBUS,
766
798
return TRUE;
767
799
768
800
dbus_connection_ref (connection); /* because we may get disconnected */
769
801
770
802
if (!dbus_connection_send (connection, message, &serial))
771
803
{
772
804
dbus_message_unref (message);
775
807
}
776
808
777
809
_dbus_assert (dbus_message_has_signature (message, ""));
778
810
779
811
dbus_message_unref (message);
780
812
message = NULL;
781
813
782
814
if (!dbus_connection_get_is_connected (connection))
783
815
{
784
816
_dbus_verbose ("connection was disconnected (presumably auth failed)\n");
785
817
786
818
dbus_connection_unref (connection);
787
819
788
820
return TRUE;
789
821
}
790
822
791
823
/* send our message */
792
824
bus_test_run_clients_loop (SEND_PENDING (connection));
793
825
794
826
if (!dbus_connection_get_is_connected (connection))
795
827
{
796
828
_dbus_verbose ("connection was disconnected (presumably auth failed)\n");
797
829
798
830
dbus_connection_unref (connection);
799
831
800
832
return TRUE;
801
833
}
802
834
803
835
block_connection_until_message_from_bus (context, connection, "reply to Hello");
804
836
805
837
if (!dbus_connection_get_is_connected (connection))
806
838
{
807
839
_dbus_verbose ("connection was disconnected (presumably auth failed)\n");
808
840
809
841
dbus_connection_unref (connection);
810
842
811
843
return TRUE;
812
844
}
813
845
814
846
dbus_connection_unref (connection);
815
847
816
848
message = pop_message_waiting_for_memory (connection);
817
849
if (message == NULL)
818
850
{
830
862
dbus_message_get_sender (message) : "(none)");
831
863
goto out;
832
864
}
833
865
834
866
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
835
867
{
836
868
if (dbus_message_is_error (message,
848
880
else
849
881
{
850
882
CheckServiceOwnerChangedData socd;
851
883
852
884
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
853
885
{
854
886
; /* good, expected */
884
916
885
917
while (!dbus_bus_set_unique_name (connection, name))
886
918
_dbus_wait_for_memory ();
887
919
888
920
socd.expected_kind = SERVICE_CREATED;
889
921
socd.expected_service_name = name;
890
922
socd.failed = FALSE;
891
923
socd.skip_connection = connection; /* we haven't done AddMatch so won't get it ourselves */
892
924
bus_test_clients_foreach (check_service_owner_changed_foreach,
893
925
&socd);
894
926
895
927
if (socd.failed)
896
928
goto out;
897
929
912
944
"NameAcquired");
913
945
goto out;
914
946
}
915
947
916
948
retry_get_acquired_name:
917
949
if (!dbus_message_get_args (message, &error,
918
950
DBUS_TYPE_STRING, &acquired,
946
978
947
979
if (!check_no_leftovers (context))
948
980
goto out;
949
981
950
982
retval = TRUE;
951
983
952
984
out:
953
_dbus_verbose ("ending %s retval = %d\n", _DBUS_FUNCTION_NAME, retval);
954
985
_dbus_verbose ("ending - retval = %d\n", retval);
986
955
987
dbus_error_free (&error);
956
988
957
989
if (message)
958
990
dbus_message_unref (message);
959
991
960
992
if (name_message)
961
993
dbus_message_unref (name_message);
962
994
963
995
return retval;
964
996
}
965
997
980
1012
message = NULL;
981
1013
982
1014
_dbus_verbose ("check_double_hello_message for %p\n", connection);
983
1015
984
1016
message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
985
1017
DBUS_PATH_DBUS,
986
1018
DBUS_INTERFACE_DBUS,
988
1020
989
1021
if (message == NULL)
990
1022
return TRUE;
991
1023
992
1024
if (!dbus_connection_send (connection, message, &serial))
993
1025
{
994
1026
dbus_message_unref (message);
1006
1038
1007
1039
if (!dbus_connection_get_is_connected (connection))
1008
1040
{
1009
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1010
1041
_dbus_verbose ("connection was disconnected\n");
1042
1011
1043
dbus_connection_unref (connection);
1012
1044
1013
1045
return TRUE;
1014
1046
}
1015
1047
1016
1048
dbus_connection_unref (connection);
1017
1049
1018
1050
message = pop_message_waiting_for_memory (connection);
1019
1051
if (message == NULL)
1020
1052
{
1032
1064
dbus_message_get_sender (message) : "(none)");
1033
1065
goto out;
1034
1066
}
1035
1067
1036
1068
if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
1037
1069
{
1038
1070
warn_unexpected (connection, message, "method return for Hello");
1041
1073
1042
1074
if (!check_no_leftovers (context))
1043
1075
goto out;
1044
1076
1045
1077
retval = TRUE;
1046
1078
1047
1079
out:
1048
1080
dbus_error_free (&error);
1049
1081
1050
1082
if (message)
1051
1083
dbus_message_unref (message);
1052
1084
1053
1085
return retval;
1054
1086
}
1055
1087
1072
1104
message = NULL;
1073
1105
1074
1106
_dbus_verbose ("check_get_connection_unix_user for %p\n", connection);
1075
1107
1076
1108
message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1077
1109
DBUS_PATH_DBUS,
1078
1110
DBUS_INTERFACE_DBUS,
1083
1115
1084
1116
base_service_name = dbus_bus_get_unique_name (connection);
1085
1117
1086
if (!dbus_message_append_args (message,
1118
if (!dbus_message_append_args (message,
1087
1119
DBUS_TYPE_STRING, &base_service_name,
1088
1120
DBUS_TYPE_INVALID))
1089
1121
{
1108
1140
1109
1141
if (!dbus_connection_get_is_connected (connection))
1110
1142
{
1111
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1112
1143
_dbus_verbose ("connection was disconnected\n");
1144
1113
1145
dbus_connection_unref (connection);
1114
1146
1115
1147
return TRUE;
1116
1148
}
1117
1149
1183
1215
1184
1216
out:
1185
1217
dbus_error_free (&error);
1186
1218
1187
1219
if (message)
1188
1220
dbus_message_unref (message);
1189
1221
1190
1222
return retval;
1191
1223
}
1192
1224
1209
1241
message = NULL;
1210
1242
1211
1243
_dbus_verbose ("check_get_connection_unix_process_id for %p\n", connection);
1212
1244
1213
1245
message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1214
1246
DBUS_PATH_DBUS,
1215
1247
DBUS_INTERFACE_DBUS,
1220
1252
1221
1253
base_service_name = dbus_bus_get_unique_name (connection);
1222
1254
1223
if (!dbus_message_append_args (message,
1255
if (!dbus_message_append_args (message,
1224
1256
DBUS_TYPE_STRING, &base_service_name,
1225
1257
DBUS_TYPE_INVALID))
1226
1258
{
1245
1277
1246
1278
if (!dbus_connection_get_is_connected (connection))
1247
1279
{
1248
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1249
1280
_dbus_verbose ("connection was disconnected\n");
1281
1250
1282
dbus_connection_unref (connection);
1251
1283
1252
1284
return TRUE;
1253
1285
}
1254
1286
1278
1310
*/
1279
1311
_dbus_verbose ("Windows correctly does not support GetConnectionUnixProcessID\n");
1280
1312
}
1281
#endif
1313
#endif
1282
1314
else
1283
1315
{
1284
1316
warn_unexpected (connection, message, "not this error");
1285
1317
1286
1318
goto out;
1287
1319
}
1288
1320
}
1291
1323
#ifdef DBUS_WIN
1292
1324
warn_unexpected (connection, message, "GetConnectionUnixProcessID to fail on Windows");
1293
1325
goto out;
1294
#else
1326
#else
1295
1327
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
1296
1328
{
1297
1329
; /* good, expected */
1350
1382
1351
1383
out:
1352
1384
dbus_error_free (&error);
1353
1385
1354
1386
if (message)
1355
1387
dbus_message_unref (message);
1356
1388
1357
1389
return retval;
1358
1390
}
1359
1391
1375
1407
message = NULL;
1376
1408
1377
1409
_dbus_verbose ("check_add_match_all for %p\n", connection);
1378
1410
1379
1411
message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1380
1412
DBUS_PATH_DBUS,
1381
1413
DBUS_INTERFACE_DBUS,
1391
1423
dbus_message_unref (message);
1392
1424
return TRUE;
1393
1425
}
1394
1426
1395
1427
if (!dbus_connection_send (connection, message, &serial))
1396
1428
{
1397
1429
dbus_message_unref (message);
1402
1434
message = NULL;
1403
1435
1404
1436
dbus_connection_ref (connection); /* because we may get disconnected */
1405
1437
1406
1438
/* send our message */
1407
1439
bus_test_run_clients_loop (SEND_PENDING (connection));
1408
1440
1409
1441
if (!dbus_connection_get_is_connected (connection))
1410
1442
{
1411
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1412
1443
_dbus_verbose ("connection was disconnected\n");
1444
1413
1445
dbus_connection_unref (connection);
1414
1446
1415
1447
return TRUE;
1416
1448
}
1417
1449
1418
1450
block_connection_until_message_from_bus (context, connection, "reply to AddMatch");
1419
1451
1420
1452
if (!dbus_connection_get_is_connected (connection))
1421
1453
{
1422
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1423
1454
_dbus_verbose ("connection was disconnected\n");
1455
1424
1456
dbus_connection_unref (connection);
1425
1457
1426
1458
return TRUE;
1427
1459
}
1428
1460
1429
1461
dbus_connection_unref (connection);
1430
1462
1431
1463
message = pop_message_waiting_for_memory (connection);
1432
1464
if (message == NULL)
1433
1465
{
1445
1477
dbus_message_get_sender (message) : "(none)");
1446
1478
goto out;
1447
1479
}
1448
1480
1449
1481
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
1450
1482
{
1451
1483
if (dbus_message_is_error (message,
1477
1509
1478
1510
if (!check_no_leftovers (context))
1479
1511
goto out;
1480
1512
1481
1513
retval = TRUE;
1482
1514
1483
1515
out:
1484
1516
dbus_error_free (&error);
1485
1517
1486
1518
if (message)
1487
1519
dbus_message_unref (message);
1488
1520
1489
1521
return retval;
1490
1522
}
1491
1523
1500
1532
1501
1533
dbus_error_init (&error);
1502
1534
1503
connection = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
1535
connection = dbus_connection_open_private (TEST_CONNECTION, &error);
1504
1536
if (connection == NULL)
1505
1537
{
1506
1538
_DBUS_ASSERT_ERROR_IS_SET (&error);
1516
1548
}
1517
1549
1518
1550
spin_connection_until_authenticated (context, connection);
1519
1551
1520
1552
if (!check_hello_message (context, connection))
1521
1553
return FALSE;
1522
1554
1523
1555
if (dbus_bus_get_unique_name (connection) == NULL)
1524
1556
{
1525
1557
/* We didn't successfully register, so we can't
1531
1563
{
1532
1564
if (!check_add_match_all (context, connection))
1533
1565
return FALSE;
1534
1566
1535
1567
kill_client_connection (context, connection);
1536
1568
}
1537
1569
1552
1584
dbus_bool_t retval;
1553
1585
const char *nonexistent = NONEXISTENT_SERVICE_NAME;
1554
1586
dbus_uint32_t flags;
1555
1587
1556
1588
message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
1557
1589
DBUS_PATH_DBUS,
1558
1590
DBUS_INTERFACE_DBUS,
1559
1591
"StartServiceByName");
1560
1592
1561
1593
if (message == NULL)
1562
1594
return TRUE;
1563
1595
1564
1596
dbus_message_set_auto_start (message, FALSE);
1565
1597
1566
1598
flags = 0;
1567
1599
if (!dbus_message_append_args (message,
1568
1600
DBUS_TYPE_STRING, &nonexistent,
1572
1604
dbus_message_unref (message);
1573
1605
return TRUE;
1574
1606
}
1575
1607
1576
1608
if (!dbus_connection_send (connection, message, &serial))
1577
1609
{
1578
1610
dbus_message_unref (message);
1588
1620
1589
1621
if (!dbus_connection_get_is_connected (connection))
1590
1622
{
1591
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1623
_dbus_verbose ("connection was disconnected\n");
1592
1624
return TRUE;
1593
1625
}
1594
1626
1595
1627
retval = FALSE;
1596
1628
1597
1629
message = pop_message_waiting_for_memory (connection);
1598
1630
if (message == NULL)
1599
1631
{
1613
1645
dbus_message_get_sender (message) : "(none)");
1614
1646
goto out;
1615
1647
}
1616
1648
1617
1649
if (dbus_message_is_error (message,
1618
1650
DBUS_ERROR_NO_MEMORY))
1619
1651
{
1638
1670
}
1639
1671
1640
1672
retval = TRUE;
1641
1673
1642
1674
out:
1643
1675
if (message)
1644
1676
dbus_message_unref (message);
1645
1677
1646
1678
return retval;
1647
1679
}
1648
1680
1656
1688
DBusMessage *message;
1657
1689
dbus_uint32_t serial;
1658
1690
dbus_bool_t retval;
1659
1691
1660
1692
message = dbus_message_new_method_call (NONEXISTENT_SERVICE_NAME,
1661
1693
"/org/freedesktop/TestSuite",
1662
1694
"org.freedesktop.TestSuite",
1663
1695
"Echo");
1664
1696
1665
1697
if (message == NULL)
1666
1698
return TRUE;
1667
1699
1668
1700
if (!dbus_connection_send (connection, message, &serial))
1669
1701
{
1670
1702
dbus_message_unref (message);
1680
1712
1681
1713
if (!dbus_connection_get_is_connected (connection))
1682
1714
{
1683
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
1715
_dbus_verbose ("connection was disconnected\n");
1684
1716
return TRUE;
1685
1717
}
1686
1718
1687
1719
retval = FALSE;
1688
1720
1689
1721
message = pop_message_waiting_for_memory (connection);
1690
1722
1691
1723
if (message == NULL)
1706
1738
dbus_message_get_sender (message) : "(none)");
1707
1739
goto out;
1708
1740
}
1709
1741
1710
1742
if (dbus_message_is_error (message,
1711
1743
DBUS_ERROR_NO_MEMORY))
1712
1744
{
1731
1763
}
1732
1764
1733
1765
retval = TRUE;
1734
1766
1735
1767
out:
1736
1768
if (message)
1737
1769
dbus_message_unref (message);
1738
1770
1739
1771
return retval;
1740
1772
}
1741
1773
1749
1781
dbus_bool_t retval;
1750
1782
DBusError error;
1751
1783
const char *base_service, *base_service_from_bus, *old_owner;
1752
1784
1753
1785
retval = FALSE;
1754
1786
1755
1787
dbus_error_init (&error);
1756
1788
base_service = NULL;
1757
1789
old_owner = NULL;
1758
1790
base_service_from_bus = NULL;
1759
1791
1760
1792
message = initial_message;
1761
dbus_message_ref (message);
1793
dbus_message_ref (message);
1762
1794
1763
1795
if (dbus_message_is_signal (message,
1764
1796
DBUS_INTERFACE_DBUS,
1798
1830
base_service);
1799
1831
goto out;
1800
1832
}
1801
1833
1802
1834
if (strcmp (base_service, base_service_from_bus) != 0)
1803
1835
{
1804
1836
_dbus_warn ("Expected base service activation, got \"%s\" instead with owner \"%s\"\n",
1812
1844
old_owner);
1813
1845
goto out;
1814
1846
}
1815
1847
1816
1848
socd.expected_kind = SERVICE_CREATED;
1817
1849
socd.expected_service_name = base_service;
1818
1850
socd.failed = FALSE;
1819
1851
socd.skip_connection = connection;
1820
1852
bus_test_clients_foreach (check_service_owner_changed_foreach,
1821
1853
&socd);
1822
1854
1823
1855
if (socd.failed)
1824
1856
goto out;
1825
1857
}
1834
1866
*base_service_p = base_service;
1835
1867
1836
1868
retval = TRUE;
1837
1869
1838
1870
out:
1839
1871
if (message)
1840
1872
dbus_message_unref (message);
1854
1886
dbus_bool_t retval;
1855
1887
DBusError error;
1856
1888
dbus_uint32_t activation_result;
1857
1889
1858
1890
retval = FALSE;
1859
1891
1860
1892
dbus_error_init (&error);
1861
1893
1862
1894
message = initial_message;
1923
1955
socd.expected_service_name = service_name;
1924
1956
bus_test_clients_foreach (check_service_owner_changed_foreach,
1925
1957
&socd);
1926
1958
1927
1959
if (socd.failed)
1928
1960
goto out;
1929
1961
1930
1962
dbus_message_unref (message);
1931
1963
service_name = NULL;
1932
1964
old_owner = NULL;
1933
1965
base_service_from_bus = NULL;
1934
1966
1935
1967
message = pop_message_waiting_for_memory (connection);
1936
1968
if (message == NULL)
1937
1969
{
1943
1975
else
1944
1976
{
1945
1977
warn_unexpected (connection, message, "NameOwnerChanged for the activated name");
1946
1978
1947
1979
goto out;
1948
1980
}
1949
1981
1950
1982
if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
1951
1983
{
1952
1984
warn_unexpected (connection, message, "reply to StartServiceByName");
1984
2016
1985
2017
dbus_message_unref (message);
1986
2018
message = NULL;
1987
2019
1988
2020
if (!check_no_leftovers (context))
1989
2021
{
1990
2022
_dbus_warn ("Messages were left over after verifying existent activation results\n");
1992
2024
}
1993
2025
1994
2026
retval = TRUE;
1995
2027
1996
2028
out:
1997
2029
if (message)
1998
2030
dbus_message_unref (message);
1999
2031
dbus_error_free (&error);
2000
2032
2001
2033
return retval;
2002
2034
}
2003
2035
2011
2043
DBusMessage *message;
2012
2044
dbus_bool_t retval;
2013
2045
DBusError error;
2014
2046
2015
2047
retval = FALSE;
2016
2048
2017
2049
dbus_error_init (&error);
2018
2050
2019
2051
message = initial_message;
2025
2057
{
2026
2058
const char *service_name;
2027
2059
CheckServiceOwnerChangedData socd;
2028
2060
2029
2061
reget_service_name_arg:
2030
2062
if (!dbus_message_get_args (message, &error,
2031
2063
DBUS_TYPE_STRING, &service_name,
2046
2078
goto out;
2047
2079
}
2048
2080
}
2049
2081
2050
2082
if (strcmp (service_name, activated_name) != 0)
2051
2083
{
2052
2084
_dbus_warn ("Expected to see service %s created, saw %s instead\n",
2053
2085
activated_name, service_name);
2054
2086
goto out;
2055
2087
}
2056
2088
2057
2089
socd.expected_kind = SERVICE_CREATED;
2058
2090
socd.expected_service_name = service_name;
2059
2091
socd.failed = FALSE;
2060
socd.skip_connection = connection;
2092
socd.skip_connection = connection;
2061
2093
bus_test_clients_foreach (check_service_owner_changed_foreach,
2062
2094
&socd);
2063
2095
2064
2096
if (socd.failed)
2065
2097
goto out;
2066
2098
2067
2099
/* Note that this differs from regular activation in that we don't get a
2068
2100
* reply to ActivateService here.
2069
2101
*/
2070
2102
2071
2103
dbus_message_unref (message);
2072
2104
message = NULL;
2073
2105
service_name = NULL;
2075
2107
else
2076
2108
{
2077
2109
warn_unexpected (connection, message, "NameOwnerChanged for the activated name");
2078
2110
2079
2111
goto out;
2080
2112
}
2081
2113
2082
2114
retval = TRUE;
2083
2115
2084
2116
out:
2085
2117
if (message)
2086
2118
dbus_message_unref (message);
2087
2119
2088
2120
return retval;
2089
2121
}
2090
2122
2098
2130
CheckServiceOwnerChangedData socd;
2099
2131
2100
2132
retval = FALSE;
2101
2133
2102
2134
/* Now we are expecting ServiceOwnerChanged (deletion) messages for the base
2103
2135
* service and the activated_name. The base service
2104
2136
* notification is required to come last.
2108
2140
socd.failed = FALSE;
2109
2141
socd.skip_connection = NULL;
2110
2142
bus_test_clients_foreach (check_service_owner_changed_foreach,
2111
&socd);
2143
&socd);
2112
2144
2113
2145
if (socd.failed)
2114
2146
goto out;
2115
2147
2116
2148
socd.expected_kind = SERVICE_DELETED;
2117
2149
socd.expected_service_name = base_service;
2118
2150
socd.failed = FALSE;
2124
2156
goto out;
2125
2157
2126
2158
retval = TRUE;
2127
2159
2128
2160
out:
2129
2161
return retval;
2130
2162
}
2139
2171
DBusMessage *message;
2140
2172
dbus_uint32_t serial;
2141
2173
dbus_bool_t retval;
2142
2174
2143
2175
_dbus_verbose ("Sending exit message to the test service\n");
2144
2176
2145
2177
retval = FALSE;
2146
2178
2147
2179
/* Kill off the test service by sending it a quit message */
2148
2180
message = dbus_message_new_method_call (service_name,
2149
2181
"/org/freedesktop/TestSuite",
2150
2182
"org.freedesktop.TestSuite",
2151
2183
"Exit");
2152
2184
2153
2185
if (message == NULL)
2154
2186
{
2155
2187
/* Do this again; we still need the service to exit... */
2156
2188
if (!check_send_exit_to_service (context, connection,
2157
2189
service_name, base_service))
2158
2190
goto out;
2159
2191
2160
2192
return TRUE;
2161
2193
}
2162
2194
2163
2195
if (!dbus_connection_send (connection, message, &serial))
2164
2196
{
2165
2197
dbus_message_unref (message);
2168
2200
if (!check_send_exit_to_service (context, connection,
2169
2201
service_name, base_service))
2170
2202
goto out;
2171
2203
2172
2204
return TRUE;
2173
2205
}
2174
2206
2190
2222
dbus_connection_return_message (connection, message);
2191
2223
message = NULL;
2192
2224
}
2193
2225
2194
2226
if (!got_error)
2195
2227
{
2196
2228
/* If no error, wait for the test service to exit */
2197
2229
block_connection_until_message_from_bus (context, connection, "test service to exit");
2198
2230
2199
2231
bus_test_run_everything (context);
2200
2232
}
2201
2233
2210
2242
"error with the correct reply serial");
2211
2243
goto out;
2212
2244
}
2213
2245
2214
2246
if (!dbus_message_is_error (message,
2215
2247
DBUS_ERROR_NO_MEMORY))
2216
2248
{
2238
2270
* stuff.
2239
2271
*/
2240
2272
message = pop_message_waiting_for_memory (connection);
2241
2273
2242
2274
if (message == NULL)
2243
2275
{
2244
2276
warn_unexpected (connection, NULL,
2259
2291
"error with the correct reply serial");
2260
2292
goto out;
2261
2293
}
2262
2294
2263
2295
_dbus_verbose ("Got error %s after test service exited\n",
2264
2296
dbus_message_get_error_name (message));
2265
2297
2266
2298
if (!check_no_leftovers (context))
2267
2299
{
2268
2300
_dbus_warn ("Messages were left over after %s\n",
2270
2302
goto out;
2271
2303
}
2272
2304
}
2273
2305
2274
2306
retval = TRUE;
2275
2307
2276
2308
out:
2277
2309
if (message)
2278
2310
dbus_message_unref (message);
2279
2311
2280
2312
return retval;
2281
2313
}
2282
2314
2291
2323
va_list ap;
2292
2324
dbus_bool_t error_found;
2293
2325
const char *error_name;
2294
2326
2295
2327
retval = FALSE;
2296
2328
2297
2329
message = pop_message_waiting_for_memory (connection);
2298
2330
if (message == NULL)
2299
2331
{
2332
2364
}
2333
2365
2334
2366
retval = TRUE;
2335
2367
2336
2368
out:
2337
2369
if (message)
2338
2370
dbus_message_unref (message);
2339
2371
2340
2372
return retval;
2341
2373
}
2342
2374
2343
2375
typedef enum
2344
{
2376
{
2345
2377
GOT_SERVICE_CREATED,
2346
2378
GOT_SERVICE_DELETED,
2347
2379
GOT_ERROR,
2348
GOT_SOMETHING_ELSE
2380
GOT_SOMETHING_ELSE
2349
2381
} GotServiceInfo;
2350
2382
2351
2383
static GotServiceInfo
2419
2451
dbus_uint32_t flags;
2420
2452
2421
2453
base_service_message = NULL;
2422
2454
2423
2455
message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
2424
2456
DBUS_PATH_DBUS,
2425
2457
DBUS_INTERFACE_DBUS,
2429
2461
return TRUE;
2430
2462
2431
2463
dbus_message_set_auto_start (message, FALSE);
2432
2464
2433
2465
flags = 0;
2434
2466
if (!dbus_message_append_args (message,
2435
2467
DBUS_TYPE_STRING, &existent,
2439
2471
dbus_message_unref (message);
2440
2472
return TRUE;
2441
2473
}
2442
2474
2443
2475
if (!dbus_connection_send (connection, message, &serial))
2444
2476
{
2445
2477
dbus_message_unref (message);
2460
2492
2461
2493
if (!dbus_connection_get_is_connected (connection))
2462
2494
{
2463
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
2495
_dbus_verbose ("connection was disconnected\n");
2464
2496
return TRUE;
2465
2497
}
2466
2498
2467
2499
retval = FALSE;
2468
2500
2469
2501
message = pop_message_waiting_for_memory (connection);
2470
2502
if (message == NULL)
2471
2503
{
2486
2518
dbus_message_get_sender (message) : "(none)");
2487
2519
goto out;
2488
2520
}
2489
2521
2490
2522
if (dbus_message_is_error (message,
2491
2523
DBUS_ERROR_NO_MEMORY))
2492
2524
{
2511
2543
else
2512
2544
{
2513
2545
GotServiceInfo message_kind;
2514
2546
2515
2547
if (!check_base_service_activated (context, connection,
2516
2548
message, &base_service))
2517
2549
goto out;
2521
2553
2522
2554
/* We may need to block here for the test service to exit or finish up */
2523
2555
block_connection_until_message_from_bus (context, connection, "test service to exit or finish up");
2524
2556
2525
2557
message = dbus_connection_borrow_message (connection);
2526
2558
if (message == NULL)
2527
2559
{
2564
2596
socd.expected_service_name = base_service;
2565
2597
socd.failed = FALSE;
2566
2598
socd.skip_connection = NULL;
2567
2599
2568
2600
bus_test_clients_foreach (check_service_owner_changed_foreach,
2569
2601
&socd);
2570
2602
2577
2609
if (message_kind != GOT_ERROR)
2578
2610
{
2579
2611
block_connection_until_message_from_bus (context, connection, "error about service exiting");
2580
2612
2581
2613
/* and process everything again */
2582
2614
bus_test_run_everything (context);
2583
2615
2584
2616
if (!check_got_error (context, connection,
2585
2617
DBUS_ERROR_SPAWN_CHILD_EXITED,
2586
2618
DBUS_ERROR_NO_MEMORY,
2598
2630
"should have been a NameOwnerChanged (creation)\n");
2599
2631
goto out;
2600
2632
}
2601
2633
2602
2634
if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME,
2603
2635
base_service, message))
2604
2636
goto out;
2605
2637
2606
2638
dbus_message_unref (message);
2607
2639
message = NULL;
2608
2640
2621
2653
}
2622
2654
2623
2655
retval = TRUE;
2624
2656
2625
2657
out:
2626
2658
if (message)
2627
2659
dbus_message_unref (message);
2628
2660
2629
2661
if (base_service_message)
2630
2662
dbus_message_unref (base_service_message);
2631
2663
2632
2664
return retval;
2633
2665
}
2634
2666
2645
2677
dbus_bool_t retval;
2646
2678
const char *segv_service;
2647
2679
dbus_uint32_t flags;
2648
2680
2649
2681
message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
2650
2682
DBUS_PATH_DBUS,
2651
2683
DBUS_INTERFACE_DBUS,
2655
2687
return TRUE;
2656
2688
2657
2689
dbus_message_set_auto_start (message, FALSE);
2658
2690
2659
2691
segv_service = "org.freedesktop.DBus.TestSuiteSegfaultService";
2660
2692
flags = 0;
2661
2693
if (!dbus_message_append_args (message,
2666
2698
dbus_message_unref (message);
2667
2699
return TRUE;
2668
2700
}
2669
2701
2670
2702
if (!dbus_connection_send (connection, message, &serial))
2671
2703
{
2672
2704
dbus_message_unref (message);
2682
2714
2683
2715
if (!dbus_connection_get_is_connected (connection))
2684
2716
{
2685
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
2717
_dbus_verbose ("connection was disconnected\n");
2686
2718
return TRUE;
2687
2719
}
2688
2720
2689
2721
retval = FALSE;
2690
2722
2691
2723
message = pop_message_waiting_for_memory (connection);
2692
2724
if (message == NULL)
2693
2725
{
2707
2739
dbus_message_get_sender (message) : "(none)");
2708
2740
goto out;
2709
2741
}
2710
2742
2711
2743
if (dbus_message_is_error (message,
2712
2744
DBUS_ERROR_NO_MEMORY))
2713
2745
{
2740
2772
}
2741
2773
2742
2774
retval = TRUE;
2743
2775
2744
2776
out:
2745
2777
if (message)
2746
2778
dbus_message_unref (message);
2747
2779
2748
2780
return retval;
2749
2781
}
2750
2782
2764
2796
"/org/freedesktop/TestSuite",
2765
2797
"org.freedesktop.TestSuite",
2766
2798
"Echo");
2767
2799
2768
2800
if (message == NULL)
2769
2801
return TRUE;
2770
2802
2771
2803
if (!dbus_connection_send (connection, message, &serial))
2772
2804
{
2773
2805
dbus_message_unref (message);
2783
2815
2784
2816
if (!dbus_connection_get_is_connected (connection))
2785
2817
{
2786
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
2818
_dbus_verbose ("connection was disconnected\n");
2787
2819
return TRUE;
2788
2820
}
2789
2821
2790
2822
retval = FALSE;
2791
2823
2792
2824
message = pop_message_waiting_for_memory (connection);
2793
2825
if (message == NULL)
2794
2826
{
2808
2840
dbus_message_get_sender (message) : "(none)");
2809
2841
goto out;
2810
2842
}
2811
2843
2812
2844
if (dbus_message_is_error (message,
2813
2845
DBUS_ERROR_NO_MEMORY))
2814
2846
{
2833
2865
}
2834
2866
2835
2867
retval = TRUE;
2836
2868
2837
2869
out:
2838
2870
if (message)
2839
2871
dbus_message_unref (message);
2840
2872
2841
2873
return retval;
2842
2874
}
2843
2875
#endif
2860
2892
"/org/freedesktop/TestSuite",
2861
2893
"org.freedesktop.TestSuite",
2862
2894
"RunHelloFromSelf");
2863
2895
2864
2896
if (message == NULL)
2865
2897
return TRUE;
2866
2898
2888
2920
* doesn't send a reply due to OOM.
2889
2921
*/
2890
2922
block_connection_until_message_from_bus (context, connection, "reply from running hello from self");
2891
2923
2892
2924
message = pop_message_waiting_for_memory (connection);
2893
2925
if (message == NULL)
2894
2926
{
2905
2937
2906
2938
dbus_message_unref (message);
2907
2939
message = NULL;
2908
2940
2909
2941
return TRUE;
2910
2942
}
2911
2943
2922
2954
"/org/freedesktop/TestSuite",
2923
2955
"org.freedesktop.DBus.Peer",
2924
2956
"Ping");
2925
2957
2926
2958
if (message == NULL)
2927
2959
return TRUE;
2928
2960
2941
2973
* doesn't send a reply due to OOM.
2942
2974
*/
2943
2975
block_connection_until_message_from_bus (context, connection, "reply from running Ping");
2944
2976
2945
2977
message = pop_message_waiting_for_memory (connection);
2946
2978
if (message == NULL)
2947
2979
{
2965
2997
2966
2998
dbus_message_unref (message);
2967
2999
message = NULL;
2968
3000
2969
3001
return TRUE;
2970
3002
}
2971
3003
2979
3011
DBusMessage *message;
2980
3012
dbus_uint32_t serial;
2981
3013
const char *machine_id;
2982
3014
2983
3015
message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
2984
3016
"/org/freedesktop/TestSuite",
2985
3017
"org.freedesktop.DBus.Peer",
2986
3018
"GetMachineId");
2987
3019
2988
3020
if (message == NULL)
2989
3021
return TRUE;
2990
3022
3003
3035
* doesn't send a reply due to OOM.
3004
3036
*/
3005
3037
block_connection_until_message_from_bus (context, connection, "reply from running GetMachineId");
3006
3038
3007
3039
message = pop_message_waiting_for_memory (connection);
3008
3040
if (message == NULL)
3009
3041
{
3039
3071
dbus_message_unref (message);
3040
3072
return FALSE;
3041
3073
}
3042
3074
3043
3075
/* We can't check that the machine id is correct because during make check it is
3044
3076
* just made up for each process separately
3045
3077
*/
3046
3078
3047
3079
dbus_message_unref (message);
3048
3080
message = NULL;
3049
3081
3050
3082
return TRUE;
3051
3083
}
3052
3084
3070
3102
"/org/freedesktop/TestSuite",
3071
3103
"org.freedesktop.TestSuite",
3072
3104
"Echo");
3073
3105
3074
3106
if (message == NULL)
3075
3107
return TRUE;
3076
3108
3102
3134
3103
3135
if (!dbus_connection_get_is_connected (connection))
3104
3136
{
3105
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3137
_dbus_verbose ("connection was disconnected\n");
3106
3138
return TRUE;
3107
3139
}
3108
3140
3109
3141
retval = FALSE;
3110
3142
3111
3143
message = pop_message_waiting_for_memory (connection);
3112
3144
if (message == NULL)
3113
3145
{
3152
3184
dbus_connection_return_message (connection, message);
3153
3185
message = NULL;
3154
3186
3155
switch (message_kind)
3187
switch (message_kind)
3156
3188
{
3157
3189
case GOT_SERVICE_CREATED:
3158
3190
message = pop_message_waiting_for_memory (connection);
3162
3194
"should have been a NameOwnerChanged (creation)\n");
3163
3195
goto out;
3164
3196
}
3165
3197
3166
3198
/* Check that ServiceOwnerChanged (creation) was correctly received */
3167
3199
if (!check_service_auto_activated (context, connection, EXISTENT_SERVICE_NAME,
3168
3200
base_service, message))
3169
3201
goto out;
3170
3202
3171
3203
dbus_message_unref (message);
3172
3204
message = NULL;
3173
3205
3179
3211
* failed to register under EXISTENT_SERVICE_NAME
3180
3212
*/
3181
3213
CheckServiceOwnerChangedData socd;
3182
3214
3183
3215
socd.expected_kind = SERVICE_DELETED;
3184
3216
socd.expected_service_name = base_service;
3185
3217
socd.failed = FALSE;
3208
3240
* doesn't send a reply due to OOM.
3209
3241
*/
3210
3242
block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation");
3211
3243
3212
3244
message = pop_message_waiting_for_memory (connection);
3213
3245
if (message == NULL)
3214
3246
{
3230
3262
3231
3263
if (!check_existent_get_machine_id (context, connection))
3232
3264
goto out;
3233
3265
3234
3266
if (!check_existent_hello_from_self (context, connection))
3235
3267
goto out;
3236
3268
3238
3270
EXISTENT_SERVICE_NAME,
3239
3271
base_service))
3240
3272
goto out;
3241
3273
3242
3274
retval = TRUE;
3243
3275
3244
3276
out:
3268
3300
"/org/freedesktop/TestSuite",
3269
3301
"org.freedesktop.TestSuite",
3270
3302
"Echo");
3271
3303
3272
3304
if (message == NULL)
3273
3305
return TRUE;
3274
3306
3287
3319
3288
3320
if (!dbus_connection_get_is_connected (connection))
3289
3321
{
3290
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3322
_dbus_verbose ("connection was disconnected\n");
3291
3323
return TRUE;
3292
3324
}
3293
3325
3294
3326
retval = FALSE;
3295
3327
3296
3328
message = pop_message_waiting_for_memory (connection);
3297
3329
if (message == NULL)
3298
3330
{
3312
3344
dbus_message_get_sender (message) : "(none)");
3313
3345
goto out;
3314
3346
}
3315
3347
3316
3348
if (dbus_message_is_error (message,
3317
3349
DBUS_ERROR_NO_MEMORY))
3318
3350
{
3338
3370
}
3339
3371
3340
3372
retval = TRUE;
3341
3373
3342
3374
out:
3343
3375
if (message)
3344
3376
dbus_message_unref (message);
3345
3377
3346
3378
return retval;
3347
3379
}
3348
3380
3383
3415
3384
3416
if (!dbus_connection_get_is_connected (connection))
3385
3417
{
3386
_dbus_warn ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3418
_dbus_warn ("connection was disconnected\n");
3387
3419
return TRUE;
3388
3420
}
3389
3421
3390
3422
retval = FALSE;
3391
3423
3392
3424
message = pop_message_waiting_for_memory (connection);
3393
3425
if (message == NULL)
3394
3426
{
3408
3440
dbus_message_get_sender (message) : "(none)");
3409
3441
goto out;
3410
3442
}
3411
3443
3412
3444
if (dbus_message_is_error (message,
3413
3445
DBUS_ERROR_NO_MEMORY))
3414
3446
{
3434
3466
}
3435
3467
3436
3468
retval = TRUE;
3437
3469
3438
3470
out:
3439
3471
if (message)
3440
3472
dbus_message_unref (message);
3441
3473
3442
3474
return retval;
3443
3475
}
3444
3476
3479
3511
3480
3512
if (!dbus_connection_get_is_connected (connection))
3481
3513
{
3482
_dbus_warn ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3514
_dbus_warn ("connection was disconnected\n");
3483
3515
return TRUE;
3484
3516
}
3485
3517
3486
3518
retval = FALSE;
3487
3519
3488
3520
message = pop_message_waiting_for_memory (connection);
3489
3521
if (message == NULL)
3490
3522
{
3504
3536
dbus_message_get_sender (message) : "(none)");
3505
3537
goto out;
3506
3538
}
3507
3539
3508
3540
if (dbus_message_is_error (message,
3509
3541
DBUS_ERROR_NO_MEMORY))
3510
3542
{
3538
3570
}
3539
3571
3540
3572
retval = TRUE;
3541
3573
3542
3574
out:
3543
3575
if (message)
3544
3576
dbus_message_unref (message);
3545
3577
3546
3578
return retval;
3547
3579
}
3548
3580
3583
3615
3584
3616
if (!dbus_connection_get_is_connected (connection))
3585
3617
{
3586
_dbus_warn ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3618
_dbus_warn ("connection was disconnected\n");
3587
3619
return TRUE;
3588
3620
}
3589
3621
3590
3622
retval = FALSE;
3591
3623
3592
3624
message = pop_message_waiting_for_memory (connection);
3593
3625
if (message == NULL)
3594
3626
{
3608
3640
dbus_message_get_sender (message) : "(none)");
3609
3641
goto out;
3610
3642
}
3611
3643
3612
3644
if (dbus_message_is_error (message,
3613
3645
DBUS_ERROR_NO_MEMORY))
3614
3646
{
3642
3674
}
3643
3675
3644
3676
retval = TRUE;
3645
3677
3646
3678
out:
3647
3679
if (message)
3648
3680
dbus_message_unref (message);
3649
3681
3650
3682
return retval;
3651
3683
}
3652
3684
3667
3699
"/org/freedesktop/TestSuite",
3668
3700
"org.freedesktop.TestSuite",
3669
3701
"Echo");
3670
3702
3671
3703
if (message == NULL)
3672
3704
return TRUE;
3673
3705
3674
3706
if (!dbus_connection_send (connection, message, &serial))
3675
3707
{
3676
3708
dbus_message_unref (message);
3686
3718
3687
3719
if (!dbus_connection_get_is_connected (connection))
3688
3720
{
3689
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3721
_dbus_verbose ("connection was disconnected\n");
3690
3722
return TRUE;
3691
3723
}
3692
3724
3693
3725
retval = FALSE;
3694
3726
3695
3727
message = pop_message_waiting_for_memory (connection);
3696
3728
if (message == NULL)
3697
3729
{
3711
3743
dbus_message_get_sender (message) : "(none)");
3712
3744
goto out;
3713
3745
}
3714
3746
3715
3747
if (dbus_message_is_error (message,
3716
3748
DBUS_ERROR_NO_MEMORY))
3717
3749
{
3737
3769
}
3738
3770
3739
3771
retval = TRUE;
3740
3772
3741
3773
out:
3742
3774
if (message)
3743
3775
dbus_message_unref (message);
3744
3776
3745
3777
return retval;
3746
3778
}
3747
3779
3767
3799
"/org/freedesktop/TestSuite",
3768
3800
"org.freedesktop.TestSuite",
3769
3801
"Echo");
3770
3802
3771
3803
if (message == NULL)
3772
3804
return TRUE;
3773
3805
3790
3822
3791
3823
if (!dbus_connection_get_is_connected (connection))
3792
3824
{
3793
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
3825
_dbus_verbose ("connection was disconnected\n");
3794
3826
return TRUE;
3795
3827
}
3796
3828
3797
3829
retval = FALSE;
3798
3830
3799
3831
message = pop_message_waiting_for_memory (connection);
3800
3832
if (message == NULL)
3801
3833
{
3840
3872
dbus_connection_return_message (connection, message);
3841
3873
message = NULL;
3842
3874
3843
switch (message_kind)
3875
switch (message_kind)
3844
3876
{
3845
3877
case GOT_SERVICE_CREATED:
3846
3878
message = pop_message_waiting_for_memory (connection);
3850
3882
"should have been a NameOwnerChanged (creation)\n");
3851
3883
goto out;
3852
3884
}
3853
3885
3854
3886
/* Check that ServiceOwnerChanged (creation) was correctly received */
3855
3887
if (!check_service_auto_activated (context, connection, SHELL_SUCCESS_SERVICE_NAME,
3856
3888
base_service, message))
3857
3889
goto out;
3858
3890
3859
3891
dbus_message_unref (message);
3860
3892
message = NULL;
3861
3893
3867
3899
* failed to register under SHELL_SUCCESS_SERVICE_NAME
3868
3900
*/
3869
3901
CheckServiceOwnerChangedData socd;
3870
3902
3871
3903
socd.expected_kind = SERVICE_DELETED;
3872
3904
socd.expected_service_name = base_service;
3873
3905
socd.failed = FALSE;
3896
3928
* doesn't send a reply due to OOM.
3897
3929
*/
3898
3930
block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation");
3899
3931
3900
3932
message = pop_message_waiting_for_memory (connection);
3901
3933
if (message == NULL)
3902
3934
{
3911
3943
}
3912
3944
3913
3945
if (!dbus_message_get_args (message, NULL,
3914
DBUS_TYPE_STRING, &argv[0],
3946
DBUS_TYPE_STRING, &argv[0],
3915
3947
DBUS_TYPE_STRING, &argv[1],
3916
3948
DBUS_TYPE_STRING, &argv[2],
3917
3949
DBUS_TYPE_STRING, &argv[3],
3924
3956
goto out;
3925
3957
}
3926
3958
3927
/* don't worry about arg[0] as it may be different
3959
/* don't worry about arg[0] as it may be different
3928
3960
depending on the path to the tests
3929
3961
*/
3930
3962
if (strcmp("-test", argv[1]) != 0)
3931
3963
{
3932
_dbus_warn ("Unexpected argv[1] in shell success service test (expected: %s, got: %s)\n",
3964
_dbus_warn ("Unexpected argv[1] in shell success service test (expected: %s, got: %s)\n",
3933
3965
"-test", argv[1]);
3934
3966
goto out;
3935
}
3967
}
3936
3968
3937
3969
if (strcmp("that", argv[2]) != 0)
3938
3970
{
3939
_dbus_warn ("Unexpected argv[2] in shell success service test (expected: %s, got: %s)\n",
3971
_dbus_warn ("Unexpected argv[2] in shell success service test (expected: %s, got: %s)\n",
3940
3972
"that", argv[2]);
3941
3973
goto out;
3942
}
3974
}
3943
3975
3944
3976
if (strcmp("we get", argv[3]) != 0)
3945
3977
{
3946
_dbus_warn ("Unexpected argv[3] in shell success service test (expected: %s, got: %s)\n",
3978
_dbus_warn ("Unexpected argv[3] in shell success service test (expected: %s, got: %s)\n",
3947
3979
"we get", argv[3]);
3948
3980
goto out;
3949
}
3950
3981
}
3982
3951
3983
if (strcmp("back", argv[4]) != 0)
3952
3984
{
3953
_dbus_warn ("Unexpected argv[4] in shell success service test (expected: %s, got: %s)\n",
3985
_dbus_warn ("Unexpected argv[4] in shell success service test (expected: %s, got: %s)\n",
3954
3986
"back", argv[4]);
3955
3987
goto out;
3956
}
3988
}
3957
3989
3958
3990
if (strcmp("--what", argv[5]) != 0)
3959
3991
{
3960
_dbus_warn ("Unexpected argv[5] in shell success service test (expected: %s, got: %s)\n",
3992
_dbus_warn ("Unexpected argv[5] in shell success service test (expected: %s, got: %s)\n",
3961
3993
"--what", argv[5]);
3962
3994
goto out;
3963
}
3995
}
3964
3996
3965
3997
if (strcmp("we put in", argv[6]) != 0)
3966
3998
{
3967
_dbus_warn ("Unexpected argv[6] in shell success service test (expected: %s, got: %s)\n",
3999
_dbus_warn ("Unexpected argv[6] in shell success service test (expected: %s, got: %s)\n",
3968
4000
"we put in", argv[6]);
3969
4001
goto out;
3970
}
4002
}
3971
4003
3972
4004
dbus_message_unref (message);
3973
4005
message = NULL;
3974
4006
3975
4007
if (!check_send_exit_to_service (context, connection,
3976
4008
SHELL_SUCCESS_SERVICE_NAME,
3977
4009
base_service))
3978
4010
goto out;
3979
4011
3980
4012
retval = TRUE;
3981
4013
3982
4014
out:
4002
4034
4003
4035
if (! (* d->func) (d->context))
4004
4036
return FALSE;
4005
4037
4006
4038
if (!check_no_leftovers (d->context))
4007
4039
{
4008
4040
_dbus_warn ("Messages were left over, should be covered by test suite\n");
4070
4102
4071
4103
if (!dbus_connection_get_is_connected (connection))
4072
4104
{
4073
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
4105
_dbus_verbose ("connection was disconnected\n");
4074
4106
4075
4107
dbus_connection_unref (connection);
4076
4108
4142
4174
*len = l;
4143
4175
}
4144
4176
}
4145
4177
4146
4178
if (!check_no_leftovers (context))
4147
4179
goto out;
4148
4180
4149
4181
retval = TRUE;
4150
4182
4151
4183
out:
4152
4184
dbus_error_free (&error);
4153
4185
4154
4186
if (message)
4155
4187
dbus_message_unref (message);
4156
4188
4184
4216
if (!_dbus_string_array_contains ((const char **)services, existent))
4185
4217
{
4186
4218
_dbus_warn ("Did not get the expected %s from ListActivatableNames\n", existent);
4219
dbus_free_string_array (services);
4187
4220
return FALSE;
4188
4221
}
4189
4222
4231
4264
4232
4265
if (!dbus_connection_get_is_connected (connection))
4233
4266
{
4234
_dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
4267
_dbus_verbose ("connection was disconnected\n");
4235
4268
return TRUE;
4236
4269
}
4237
4270
4322
4355
"should have been a NameOwnerChanged (creation)\n");
4323
4356
goto out;
4324
4357
}
4325
4358
4326
4359
if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME,
4327
4360
base_service, message))
4328
4361
goto out;
4339
4372
break;
4340
4373
}
4341
4374
}
4342
4375
4343
4376
if (!check_get_services (context, connection, "ListNames", &services, &len))
4344
4377
{
4345
4378
return TRUE;
4383
4416
4384
4417
if (! (* d->func) (d->context, d->connection))
4385
4418
return FALSE;
4386
4419
4387
4420
if (!check_no_leftovers (d->context))
4388
4421
{
4389
4422
_dbus_warn ("Messages were left over, should be covered by test suite\n");
4404
4437
d.func = func;
4405
4438
d.context = context;
4406
4439
d.connection = connection;
4407
4440
4408
4441
if (!_dbus_test_oom_handling (description, check_oom_check2_func,
4409
4442
&d))
4410
4443
{
4427
4460
{
4428
4461
_dbus_string_free (&full);
4429
4462
return FALSE;
4430
}
4463
}
4431
4464
4432
4465
_dbus_string_init_const (&file, filename);
4433
4466
4434
4467
if (!_dbus_concat_dir_and_file (&full, &file))
4435
4468
{
4436
4469
_dbus_string_free (&full);
4437
4470
return FALSE;
4438
4471
}
4439
4472
4440
_dbus_verbose ("Setting TEST_LAUNCH_HELPER_CONFIG to '%s'\n",
4473
_dbus_verbose ("Setting TEST_LAUNCH_HELPER_CONFIG to '%s'\n",
4441
4474
_dbus_string_get_const_data (&full));
4442
4475
4443
4476
_dbus_setenv ("TEST_LAUNCH_HELPER_CONFIG", _dbus_string_get_const_data (&full));
4444
4477
4445
4478
_dbus_string_free (&full);
4463
4496
_dbus_assert_not_reached ("no memory setting TEST_LAUNCH_HELPER_CONFIG");
4464
4497
4465
4498
dbus_error_init (&error);
4466
4499
4467
4500
context = bus_context_new_test (test_data_dir, filename);
4468
4501
if (context == NULL)
4469
4502
return FALSE;
4470
4471
foo = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
4503
4504
foo = dbus_connection_open_private (TEST_CONNECTION, &error);
4472
4505
if (foo == NULL)
4473
4506
_dbus_assert_not_reached ("could not alloc connection");
4474
4507
4476
4509
_dbus_assert_not_reached ("could not set up connection");
4477
4510
4478
4511
spin_connection_until_authenticated (context, foo);
4479
4512
4480
4513
if (!check_hello_message (context, foo))
4481
4514
_dbus_assert_not_reached ("hello message failed");
4482
4515
4485
4518
4486
4519
if (!check_add_match_all (context, foo))
4487
4520
_dbus_assert_not_reached ("AddMatch message failed");
4488
4489
bar = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
4521
4522
bar = dbus_connection_open_private (TEST_CONNECTION, &error);
4490
4523
if (bar == NULL)
4491
4524
_dbus_assert_not_reached ("could not alloc connection");
4492
4525
4494
4527
_dbus_assert_not_reached ("could not set up connection");
4495
4528
4496
4529
spin_connection_until_authenticated (context, bar);
4497
4530
4498
4531
if (!check_hello_message (context, bar))
4499
4532
_dbus_assert_not_reached ("hello message failed");
4500
4533
4501
4534
if (!check_add_match_all (context, bar))
4502
4535
_dbus_assert_not_reached ("AddMatch message failed");
4503
4504
baz = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
4536
4537
baz = dbus_connection_open_private (TEST_CONNECTION, &error);
4505
4538
if (baz == NULL)
4506
4539
_dbus_assert_not_reached ("could not alloc connection");
4507
4540
4509
4542
_dbus_assert_not_reached ("could not set up connection");
4510
4543
4511
4544
spin_connection_until_authenticated (context, baz);
4512
4545
4513
4546
if (!check_hello_message (context, baz))
4514
4547
_dbus_assert_not_reached ("hello message failed");
4515
4548
4516
4549
if (!check_add_match_all (context, baz))
4517
4550
_dbus_assert_not_reached ("AddMatch message failed");
4518
4551
4552
#ifdef DBUS_WIN_FIXME
4553
_dbus_warn("TODO: testing of GetConnectionUnixUser message skipped for now\n");
4554
_dbus_warn("TODO: testing of GetConnectionUnixProcessID message skipped for now\n");
4555
#else
4519
4556
if (!check_get_connection_unix_user (context, baz))
4520
4557
_dbus_assert_not_reached ("GetConnectionUnixUser message failed");
4521
4558
4522
4559
if (!check_get_connection_unix_process_id (context, baz))
4523
4560
_dbus_assert_not_reached ("GetConnectionUnixProcessID message failed");
4561
#endif
4524
4562
4525
4563
if (!check_list_services (context, baz))
4526
4564
_dbus_assert_not_reached ("ListActivatableNames message failed");
4527
4565
4528
4566
if (!check_no_leftovers (context))
4529
4567
{
4530
4568
_dbus_warn ("Messages were left over after setting up initial connections\n");
4531
4569
_dbus_assert_not_reached ("initial connection setup failed");
4532
4570
}
4533
4571
4534
4572
check1_try_iterations (context, "create_and_hello",
4535
4573
check_hello_connection);
4536
4574
4537
4575
check2_try_iterations (context, foo, "nonexistent_service_no_auto_start",
4538
4576
check_nonexistent_service_no_auto_start);
4539
4577
4543
4581
check2_try_iterations (context, foo, "segfault_service_no_auto_start",
4544
4582
check_segfault_service_no_auto_start);
4545
4583
#endif
4546
4584
4547
4585
check2_try_iterations (context, foo, "existent_service_no_auto_start",
4548
4586
check_existent_service_no_auto_start);
4549
4587
4550
4588
check2_try_iterations (context, foo, "nonexistent_service_auto_start",
4551
4589
check_nonexistent_service_auto_start);
4552
4553
4554
#ifdef DBUS_WIN_FIXME
4590
4591
4592
#ifdef DBUS_WIN_FIXME
4555
4593
_dbus_warn("TODO: dispatch.c segfault_service_auto_start test\n");
4556
4594
#else
4557
4595
/* only do the segfault test if we are not using the launcher */
4576
4614
check2_try_iterations (context, foo, "existent_service_auto_auto_start",
4577
4615
check_existent_service_auto_start);
4578
4616
#endif
4579
4617
4580
4618
if (!check_existent_service_auto_start (context, foo))
4581
4619
_dbus_assert_not_reached ("existent service auto start failed");
4582
4620
4590
4628
kill_client_connection_unchecked (baz);
4591
4629
4592
4630
bus_context_unref (context);
4593
4631
4594
4632
return TRUE;
4595
4633
}
4596
4634
4605
4643
/* save the config name for the activation helper */
4606
4644
if (!setenv_TEST_LAUNCH_HELPER_CONFIG (test_data_dir, filename))
4607
4645
_dbus_assert_not_reached ("no memory setting TEST_LAUNCH_HELPER_CONFIG");
4608
4646
4609
4647
dbus_error_init (&error);
4610
4648
4611
4649
context = bus_context_new_test (test_data_dir, filename);
4612
4650
if (context == NULL)
4613
4651
return FALSE;
4614
4615
foo = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
4652
4653
foo = dbus_connection_open_private (TEST_CONNECTION, &error);
4616
4654
if (foo == NULL)
4617
4655
_dbus_assert_not_reached ("could not alloc connection");
4618
4656
4647
4685
kill_client_connection_unchecked (foo);
4648
4686
4649
4687
bus_context_unref (context);
4650
4688
4651
4689
return TRUE;
4652
4690
}
4653
4691
4660
4698
"valid-config-files/debug-allow-all.conf", FALSE))
4661
4699
return FALSE;
4662
4700
4701
#ifdef DBUS_WIN
4702
_dbus_warn("Info: Launch helper activation tests skipped because launch-helper is not supported yet\n");
4703
#else
4663
4704
/* run launch-helper activation tests */
4664
4705
_dbus_verbose ("Launch helper activation tests\n");
4665
4706
if (!bus_dispatch_test_conf (test_data_dir,
4670
4711
if (!bus_dispatch_test_conf_fail (test_data_dir,
4671
4712
"valid-config-files-system/debug-allow-all-fail.conf"))
4672
4713
return FALSE;
4714
#endif
4673
4715
4674
4716
return TRUE;
4675
4717
}
4682
4724
DBusError error;
4683
4725
4684
4726
dbus_error_init (&error);
4685
4727
4686
4728
/* Test SHA1 authentication */
4687
4729
_dbus_verbose ("Testing SHA1 context\n");
4688
4730
4689
4731
context = bus_context_new_test (test_data_dir,
4690
4732
"valid-config-files/debug-allow-all-sha1.conf");
4691
4733
if (context == NULL)
4692
4734
return FALSE;
4693
4735
4694
foo = dbus_connection_open_private ("debug-pipe:name=test-server", &error);
4736
foo = dbus_connection_open_private (TEST_CONNECTION, &error);
4695
4737
if (foo == NULL)
4696
4738
_dbus_assert_not_reached ("could not alloc connection");
4697
4739
4699
4741
_dbus_assert_not_reached ("could not set up connection");
4700
4742
4701
4743
spin_connection_until_authenticated (context, foo);
4702
4744
4703
4745
if (!check_hello_message (context, foo))
4704
4746
_dbus_assert_not_reached ("hello message failed");
4705
4747
4706
4748
if (!check_add_match_all (context, foo))
4707
4749
_dbus_assert_not_reached ("addmatch message failed");
4708
4750
4709
4751
if (!check_no_leftovers (context))
4710
4752
{
4711
4753
_dbus_warn ("Messages were left over after setting up initial SHA-1 connection\n");
4712
4754
_dbus_assert_not_reached ("initial connection setup failed");
4713
4755
}
4714
4756
4715
4757
check1_try_iterations (context, "create_and_hello_sha1",
4716
4758
check_hello_connection);
4717
4759
4722
4764
return TRUE;
4723
4765
}
4724
4766
4767
#ifdef HAVE_UNIX_FD_PASSING
4768
4769
dbus_bool_t
4770
bus_unix_fds_passing_test(const DBusString *test_data_dir)
4771
{
4772
BusContext *context;
4773
DBusConnection *foo, *bar;
4774
DBusError error;
4775
DBusMessage *m;
4776
dbus_bool_t b;
4777
int one[2], two[2], x, y, z;
4778
char r;
4779
4780
dbus_error_init (&error);
4781
4782
context = bus_context_new_test (test_data_dir, "valid-config-files/debug-allow-all.conf");
4783
if (context == NULL)
4784
_dbus_assert_not_reached ("could not alloc context");
4785
4786
foo = dbus_connection_open_private (TEST_CONNECTION, &error);
4787
if (foo == NULL)
4788
_dbus_assert_not_reached ("could not alloc connection");
4789
4790
if (!bus_setup_debug_client (foo))
4791
_dbus_assert_not_reached ("could not set up connection");
4792
4793
spin_connection_until_authenticated (context, foo);
4794
4795
if (!check_hello_message (context, foo))
4796
_dbus_assert_not_reached ("hello message failed");
4797
4798
if (!check_add_match_all (context, foo))
4799
_dbus_assert_not_reached ("AddMatch message failed");
4800
4801
bar = dbus_connection_open_private (TEST_CONNECTION, &error);
4802
if (bar == NULL)
4803
_dbus_assert_not_reached ("could not alloc connection");
4804
4805
if (!bus_setup_debug_client (bar))
4806
_dbus_assert_not_reached ("could not set up connection");
4807
4808
spin_connection_until_authenticated (context, bar);
4809
4810
if (!check_hello_message (context, bar))
4811
_dbus_assert_not_reached ("hello message failed");
4812
4813
if (!check_add_match_all (context, bar))
4814
_dbus_assert_not_reached ("AddMatch message failed");
4815
4816
if (!(m = dbus_message_new_signal("/", "a.b.c", "d")))
4817
_dbus_assert_not_reached ("could not alloc message");
4818
4819
if (!(_dbus_full_duplex_pipe(one, one+1, TRUE, &error)))
4820
_dbus_assert_not_reached("Failed to allocate pipe #1");
4821
4822
if (!(_dbus_full_duplex_pipe(two, two+1, TRUE, &error)))
4823
_dbus_assert_not_reached("Failed to allocate pipe #2");
4824
4825
if (!dbus_message_append_args(m,
4826
DBUS_TYPE_UNIX_FD, one,
4827
DBUS_TYPE_UNIX_FD, two,
4828
DBUS_TYPE_UNIX_FD, two,
4829
DBUS_TYPE_INVALID))
4830
_dbus_assert_not_reached("Failed to attach fds.");
4831
4832
if (!_dbus_close(one[0], &error))
4833
_dbus_assert_not_reached("Failed to close pipe #1 ");
4834
if (!_dbus_close(two[0], &error))
4835
_dbus_assert_not_reached("Failed to close pipe #2 ");
4836
4837
if (!(dbus_connection_can_send_type(foo, DBUS_TYPE_UNIX_FD)))
4838
_dbus_assert_not_reached("Connection cannot do fd passing");
4839
4840
if (!(dbus_connection_can_send_type(bar, DBUS_TYPE_UNIX_FD)))
4841
_dbus_assert_not_reached("Connection cannot do fd passing");
4842
4843
if (!dbus_connection_send (foo, m, NULL))
4844
_dbus_assert_not_reached("Failed to send fds");
4845
4846
dbus_message_unref(m);
4847
4848
bus_test_run_clients_loop (SEND_PENDING (foo));
4849
4850
bus_test_run_everything (context);
4851
4852
block_connection_until_message_from_bus (context, foo, "unix fd reception on foo");
4853
4854
if (!(m = pop_message_waiting_for_memory (foo)))
4855
_dbus_assert_not_reached("Failed to receive msg");
4856
4857
if (!dbus_message_is_signal(m, "a.b.c", "d"))
4858
_dbus_assert_not_reached("bogus message received");
4859
4860
dbus_message_unref(m);
4861
4862
block_connection_until_message_from_bus (context, bar, "unix fd reception on bar");
4863
4864
if (!(m = pop_message_waiting_for_memory (bar)))
4865
_dbus_assert_not_reached("Failed to receive msg");
4866
4867
if (!dbus_message_is_signal(m, "a.b.c", "d"))
4868
_dbus_assert_not_reached("bogus message received");
4869
4870
if (!dbus_message_get_args(m,
4871
&error,
4872
DBUS_TYPE_UNIX_FD, &x,
4873
DBUS_TYPE_UNIX_FD, &y,
4874
DBUS_TYPE_UNIX_FD, &z,
4875
DBUS_TYPE_INVALID))
4876
_dbus_assert_not_reached("Failed to parse fds.");
4877
4878
dbus_message_unref(m);
4879
4880
if (write(x, "X", 1) != 1)
4881
_dbus_assert_not_reached("Failed to write to pipe #1");
4882
if (write(y, "Y", 1) != 1)
4883
_dbus_assert_not_reached("Failed to write to pipe #2");
4884
if (write(z, "Z", 1) != 1)
4885
_dbus_assert_not_reached("Failed to write to pipe #2/2nd fd");
4886
4887
if (!_dbus_close(x, &error))
4888
_dbus_assert_not_reached("Failed to close pipe #1/other side ");
4889
if (!_dbus_close(y, &error))
4890
_dbus_assert_not_reached("Failed to close pipe #2/other side ");
4891
if (!_dbus_close(z, &error))
4892
_dbus_assert_not_reached("Failed to close pipe #2/other size 2nd fd ");
4893
4894
if (read(one[1], &r, 1) != 1 || r != 'X')
4895
_dbus_assert_not_reached("Failed to read value from pipe.");
4896
if (read(two[1], &r, 1) != 1 || r != 'Y')
4897
_dbus_assert_not_reached("Failed to read value from pipe.");
4898
if (read(two[1], &r, 1) != 1 || r != 'Z')
4899
_dbus_assert_not_reached("Failed to read value from pipe.");
4900
4901
if (!_dbus_close(one[1], &error))
4902
_dbus_assert_not_reached("Failed to close pipe #1 ");
4903
if (!_dbus_close(two[1], &error))
4904
_dbus_assert_not_reached("Failed to close pipe #2 ");
4905
4906
_dbus_verbose ("Disconnecting foo\n");
4907
kill_client_connection_unchecked (foo);
4908
4909
_dbus_verbose ("Disconnecting bar\n");
4910
kill_client_connection_unchecked (bar);
4911
4912
bus_context_unref (context);
4913
4914
return TRUE;
4915
}
4916
#endif
4917
4725
4918
#endif /* DBUS_BUILD_TESTS */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1