D-Bus: dbus-auth-script.c Source File

D-Bus 1.8.16

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

- File List

dbus-auth-script.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-auth-script.c Test DBusAuth using a special script file (internal to D-Bus implementation)
3 *
4 * Copyright (C) 2003 Red Hat, Inc.
5 *
6 * Licensed under the Academic Free License version 2.1
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 */
23 #include <config.h>
24
25 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
26
27 #include "dbus-auth-script.h"
28 #include "dbus-auth.h"
29 #include "dbus-string.h"
30 #include "dbus-hash.h"
31 #include "dbus-credentials.h"
32 #include "dbus-internals.h"
33
45 /* this is slightly different from the other append_quoted_string
46 * in dbus-message-builder.c
47 */
48 static dbus_bool_t
49 append_quoted_string (DBusString *dest,
50 const DBusString *quoted)
51 {
52 dbus_bool_t in_quotes = FALSE;
53 dbus_bool_t in_backslash = FALSE;
54 int i;
55
56 i = 0;
57 while (i < _dbus_string_get_length (quoted))
58 {
59 unsigned char b;
60
61 b = _dbus_string_get_byte (quoted, i);
62
63 if (in_backslash)
64 {
65 unsigned char a;
66
67 if (b == 'r')
68 a = '\r';
69 else if (b == 'n')
70 a = '\n';
71 else if (b == '\\')
72 a = '\\';
73 else
74 {
75 _dbus_warn ("bad backslashed byte %c\n", b);
76 return FALSE;
77 }
78
79 if (!_dbus_string_append_byte (dest, a))
80 return FALSE;
81
82 in_backslash = FALSE;
83 }
84 else if (b == '\\')
85 {
86 in_backslash = TRUE;
87 }
88 else if (in_quotes)
89 {
90 if (b == '\'')
91 in_quotes = FALSE;
92 else
93 {
94 if (!_dbus_string_append_byte (dest, b))
95 return FALSE;
96 }
97 }
98 else
99 {
100 if (b == '\'')
101 in_quotes = TRUE;
102 else if (b == ' ' || b == '\n' || b == '\t')
103 break; /* end on whitespace if not quoted */
104 else
105 {
106 if (!_dbus_string_append_byte (dest, b))
107 return FALSE;
108 }
109 }
110
111 ++i;
112 }
113
114 return TRUE;
115 }
116
117 static dbus_bool_t
118 same_first_word (const DBusString *a,
119 const DBusString *b)
120 {
121 int first_a_blank, first_b_blank;
122
123 _dbus_string_find_blank (a, 0, &first_a_blank);
124 _dbus_string_find_blank (b, 0, &first_b_blank);
125
126 if (first_a_blank != first_b_blank)
127 return FALSE;
128
129 return _dbus_string_equal_len (a, b, first_a_blank);
130 }
131
132 static DBusAuthState
133 auth_state_from_string (const DBusString *str)
134 {
135 if (_dbus_string_starts_with_c_str (str, "WAITING_FOR_INPUT"))
136 return DBUS_AUTH_STATE_WAITING_FOR_INPUT;
137 else if (_dbus_string_starts_with_c_str (str, "WAITING_FOR_MEMORY"))
138 return DBUS_AUTH_STATE_WAITING_FOR_MEMORY;
139 else if (_dbus_string_starts_with_c_str (str, "HAVE_BYTES_TO_SEND"))
140 return DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND;
141 else if (_dbus_string_starts_with_c_str (str, "NEED_DISCONNECT"))
142 return DBUS_AUTH_STATE_NEED_DISCONNECT;
143 else if (_dbus_string_starts_with_c_str (str, "AUTHENTICATED"))
144 return DBUS_AUTH_STATE_AUTHENTICATED;
145 else
146 return -1;
147 }
148
149 static const char*
150 auth_state_to_string (DBusAuthState state)
151 {
152 switch (state)
153 {
154 case DBUS_AUTH_STATE_WAITING_FOR_INPUT:
155 return "WAITING_FOR_INPUT";
156 case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:
157 return "WAITING_FOR_MEMORY";
158 case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:
159 return "HAVE_BYTES_TO_SEND";
160 case DBUS_AUTH_STATE_NEED_DISCONNECT:
161 return "NEED_DISCONNECT";
162 case DBUS_AUTH_STATE_AUTHENTICATED:
163 return "AUTHENTICATED";
164 }
165
166 return "unknown";
167 }
168
169 static char **
170 split_string (DBusString *str)
171 {
172 int i, j, k, count, end;
173 char **array;
174
175 end = _dbus_string_get_length (str);
176
177 i = 0;
178 _dbus_string_skip_blank (str, i, &i);
179 for (count = 0; i < end; count++)
180 {
181 _dbus_string_find_blank (str, i, &i);
182 _dbus_string_skip_blank (str, i, &i);
183 }
184
185 array = dbus_new0 (char *, count + 1);
186 if (array == NULL)
187 return NULL;
188
189 i = 0;
190 _dbus_string_skip_blank (str, i, &i);
191 for (k = 0; k < count; k++)
192 {
193 _dbus_string_find_blank (str, i, &j);
194
195 array[k] = dbus_malloc (j - i + 1);
196 if (array[k] == NULL)
197 {
198 dbus_free_string_array (array);
199 return NULL;
200 }
201 memcpy (array[k],
202 _dbus_string_get_const_data_len (str, i, j - i), j - i);
203 array[k][j - i] = '\0';
204
205 _dbus_string_skip_blank (str, j, &i);
206 }
207 array[k] = NULL;
208
209 return array;
210 }
211
212 static void
213 auth_set_unix_credentials(DBusAuth *auth,
214 dbus_uid_t uid,
215 dbus_pid_t pid)
216 {
217 DBusCredentials *credentials;
218
219 credentials = _dbus_credentials_new ();
220 if (credentials == NULL)
221 _dbus_assert_not_reached ("no memory");
222
223 if (uid != DBUS_UID_UNSET)
224 _dbus_credentials_add_unix_uid (credentials, uid);
225 if (pid != DBUS_PID_UNSET)
226 _dbus_credentials_add_pid (credentials, pid);
227
228 _dbus_auth_set_credentials (auth, credentials);
229
230 _dbus_credentials_unref (credentials);
231 }
232
243 dbus_bool_t
244 _dbus_auth_script_run (const DBusString *filename)
245 {
246 DBusString file;
247 DBusError error = DBUS_ERROR_INIT;
248 DBusString line;
249 dbus_bool_t retval;
250 int line_no;
251 DBusAuth *auth;
252 DBusString from_auth;
253 DBusAuthState state;
254 DBusString context;
255 DBusString guid;
256
257 retval = FALSE;
258 auth = NULL;
259
260 _dbus_string_init_const (&guid, "5fa01f4202cd837709a3274ca0df9d00");
261 _dbus_string_init_const (&context, "org_freedesktop_test");
262
263 if (!_dbus_string_init (&file))
264 return FALSE;
265
266 if (!_dbus_string_init (&line))
267 {
268 _dbus_string_free (&file);
269 return FALSE;
270 }
271
272 if (!_dbus_string_init (&from_auth))
273 {
274 _dbus_string_free (&file);
275 _dbus_string_free (&line);
276 return FALSE;
277 }
278
279 if (!_dbus_file_get_contents (&file, filename, &error)) {
280 _dbus_warn ("Getting contents of %s failed: %s\n",
281 _dbus_string_get_const_data (filename), error.message);
282 dbus_error_free (&error);
283 goto out;
284 }
285
286 state = DBUS_AUTH_STATE_NEED_DISCONNECT;
287 line_no = 0;
288
289 next_iteration:
290 while (_dbus_string_pop_line (&file, &line))
291 {
292 line_no += 1;
293
294 /* _dbus_warn ("%s\n", _dbus_string_get_const_data (&line)); */
295
296 _dbus_string_delete_leading_blanks (&line);
297
298 if (auth != NULL)
299 {
300 while ((state = _dbus_auth_do_work (auth)) ==
301 DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
302 {
303 const DBusString *tmp;
304 if (_dbus_auth_get_bytes_to_send (auth, &tmp))
305 {
306 int count = _dbus_string_get_length (tmp);
307
308 if (_dbus_string_copy (tmp, 0, &from_auth,
309 _dbus_string_get_length (&from_auth)))
310 _dbus_auth_bytes_sent (auth, count);
311 }
312 }
313 }
314
315 if (_dbus_string_get_length (&line) == 0)
316 {
317 /* empty line */
318 goto next_iteration;
319 }
320 else if (_dbus_string_starts_with_c_str (&line,
321 "#"))
322 {
323 /* Ignore this comment */
324 goto next_iteration;
325 }
326 #ifdef DBUS_WIN
327 else if (_dbus_string_starts_with_c_str (&line,
328 "WIN_ONLY"))
329 {
330 /* Ignore this line */
331 goto next_iteration;
332 }
333 else if (_dbus_string_starts_with_c_str (&line,
334 "UNIX_ONLY"))
335 {
336 /* skip this file */
337 _dbus_warn ("skipping unix only auth script\n");
338 retval = TRUE;
339 goto out;
340 }
341 #endif
342 #ifdef DBUS_UNIX
343 else if (_dbus_string_starts_with_c_str (&line,
344 "UNIX_ONLY"))
345 {
346 /* Ignore this line */
347 goto next_iteration;
348 }
349 else if (_dbus_string_starts_with_c_str (&line,
350 "WIN_ONLY"))
351 {
352 /* skip this file */
353 _dbus_warn ("skipping windows only auth script\n");
354 retval = TRUE;
355 goto out;
356 }
357 #endif
358 else if (_dbus_string_starts_with_c_str (&line,
359 "CLIENT"))
360 {
361 DBusCredentials *creds;
362
363 if (auth != NULL)
364 {
365 _dbus_warn ("already created a DBusAuth (CLIENT or SERVER given twice)\n");
366 goto out;
367 }
368
369 auth = _dbus_auth_client_new ();
370 if (auth == NULL)
371 {
372 _dbus_warn ("no memory to create DBusAuth\n");
373 goto out;
374 }
375
376 /* test ref/unref */
377 _dbus_auth_ref (auth);
378 _dbus_auth_unref (auth);
379
380 creds = _dbus_credentials_new_from_current_process ();
381 if (creds == NULL)
382 {
383 _dbus_warn ("no memory for credentials\n");
384 _dbus_auth_unref (auth);
385 auth = NULL;
386 goto out;
387 }
388
389 if (!_dbus_auth_set_credentials (auth, creds))
390 {
391 _dbus_warn ("no memory for setting credentials\n");
392 _dbus_auth_unref (auth);
393 auth = NULL;
394 _dbus_credentials_unref (creds);
395 goto out;
396 }
397
398 _dbus_credentials_unref (creds);
399 }
400 else if (_dbus_string_starts_with_c_str (&line,
401 "SERVER"))
402 {
403 DBusCredentials *creds;
404
405 if (auth != NULL)
406 {
407 _dbus_warn ("already created a DBusAuth (CLIENT or SERVER given twice)\n");
408 goto out;
409 }
410
411 auth = _dbus_auth_server_new (&guid);
412 if (auth == NULL)
413 {
414 _dbus_warn ("no memory to create DBusAuth\n");
415 goto out;
416 }
417
418 /* test ref/unref */
419 _dbus_auth_ref (auth);
420 _dbus_auth_unref (auth);
421
422 creds = _dbus_credentials_new_from_current_process ();
423 if (creds == NULL)
424 {
425 _dbus_warn ("no memory for credentials\n");
426 _dbus_auth_unref (auth);
427 auth = NULL;
428 goto out;
429 }
430
431 if (!_dbus_auth_set_credentials (auth, creds))
432 {
433 _dbus_warn ("no memory for setting credentials\n");
434 _dbus_auth_unref (auth);
435 auth = NULL;
436 _dbus_credentials_unref (creds);
437 goto out;
438 }
439
440 _dbus_credentials_unref (creds);
441
442 _dbus_auth_set_context (auth, &context);
443 }
444 else if (auth == NULL)
445 {
446 _dbus_warn ("must specify CLIENT or SERVER\n");
447 goto out;
448
449 }
450 else if (_dbus_string_starts_with_c_str (&line,
451 "NO_CREDENTIALS"))
452 {
453 auth_set_unix_credentials (auth, DBUS_UID_UNSET, DBUS_PID_UNSET);
454 }
455 else if (_dbus_string_starts_with_c_str (&line,
456 "ROOT_CREDENTIALS"))
457 {
458 auth_set_unix_credentials (auth, 0, DBUS_PID_UNSET);
459 }
460 else if (_dbus_string_starts_with_c_str (&line,
461 "SILLY_CREDENTIALS"))
462 {
463 auth_set_unix_credentials (auth, 4312, DBUS_PID_UNSET);
464 }
465 else if (_dbus_string_starts_with_c_str (&line,
466 "ALLOWED_MECHS"))
467 {
468 char **mechs;
469
470 _dbus_string_delete_first_word (&line);
471 mechs = split_string (&line);
472 _dbus_auth_set_mechanisms (auth, (const char **) mechs);
473 dbus_free_string_array (mechs);
474 }
475 else if (_dbus_string_starts_with_c_str (&line,
476 "SEND"))
477 {
478 DBusString to_send;
479
480 _dbus_string_delete_first_word (&line);
481
482 if (!_dbus_string_init (&to_send))
483 {
484 _dbus_warn ("no memory to allocate string\n");
485 goto out;
486 }
487
488 if (!append_quoted_string (&to_send, &line))
489 {
490 _dbus_warn ("failed to append quoted string line %d\n",
491 line_no);
492 _dbus_string_free (&to_send);
493 goto out;
494 }
495
496 _dbus_verbose ("Sending '%s'\n", _dbus_string_get_const_data (&to_send));
497
498 if (!_dbus_string_append (&to_send, "\r\n"))
499 {
500 _dbus_warn ("failed to append \r\n from line %d\n",
501 line_no);
502 _dbus_string_free (&to_send);
503 goto out;
504 }
505
506 /* Replace USERID_HEX with our username in hex */
507 {
508 int where;
509
510 if (_dbus_string_find (&to_send, 0,
511 "USERID_HEX", &where))
512 {
513 DBusString username;
514
515 if (!_dbus_string_init (&username))
516 {
517 _dbus_warn ("no memory for userid\n");
518 _dbus_string_free (&to_send);
519 goto out;
520 }
521
522 if (!_dbus_append_user_from_current_process (&username))
523 {
524 _dbus_warn ("no memory for userid\n");
525 _dbus_string_free (&username);
526 _dbus_string_free (&to_send);
527 goto out;
528 }
529
530 _dbus_string_delete (&to_send, where, strlen ("USERID_HEX"));
531
532 if (!_dbus_string_hex_encode (&username, 0,
533 &to_send, where))
534 {
535 _dbus_warn ("no memory to subst USERID_HEX\n");
536 _dbus_string_free (&username);
537 _dbus_string_free (&to_send);
538 goto out;
539 }
540
541 _dbus_string_free (&username);
542 }
543 else if (_dbus_string_find (&to_send, 0,
544 "USERNAME_HEX", &where))
545 {
546 DBusString username;
547
548 if (!_dbus_string_init (&username))
549 {
550 _dbus_warn ("no memory for username\n");
551 _dbus_string_free (&to_send);
552 goto out;
553 }
554
555 if (!_dbus_append_user_from_current_process (&username))
556 {
557 _dbus_warn ("no memory for username\n");
558 _dbus_string_free (&username);
559 _dbus_string_free (&to_send);
560 goto out;
561 }
562
563 _dbus_string_delete (&to_send, where, strlen ("USERNAME_HEX"));
564
565 if (!_dbus_string_hex_encode (&username, 0,
566 &to_send, where))
567 {
568 _dbus_warn ("no memory to subst USERNAME_HEX\n");
569 _dbus_string_free (&username);
570 _dbus_string_free (&to_send);
571 goto out;
572 }
573
574 _dbus_string_free (&username);
575 }
576 }
577
578 {
579 DBusString *buffer;
580
581 _dbus_auth_get_buffer (auth, &buffer);
582 if (!_dbus_string_copy (&to_send, 0,
583 buffer, _dbus_string_get_length (buffer)))
584 {
585 _dbus_warn ("not enough memory to call bytes_received, or can't add bytes to auth object already in end state\n");
586 _dbus_string_free (&to_send);
587 _dbus_auth_return_buffer (auth, buffer);
588 goto out;
589 }
590
591 _dbus_auth_return_buffer (auth, buffer);
592 }
593
594 _dbus_string_free (&to_send);
595 }
596 else if (_dbus_string_starts_with_c_str (&line,
597 "EXPECT_STATE"))
598 {
599 DBusAuthState expected;
600
601 _dbus_string_delete_first_word (&line);
602
603 expected = auth_state_from_string (&line);
604 if (expected < 0)
605 {
606 _dbus_warn ("bad auth state given to EXPECT_STATE\n");
607 goto parse_failed;
608 }
609
610 if (expected != state)
611 {
612 _dbus_warn ("expected auth state %s but got %s on line %d\n",
613 auth_state_to_string (expected),
614 auth_state_to_string (state),
615 line_no);
616 goto out;
617 }
618 }
619 else if (_dbus_string_starts_with_c_str (&line,
620 "EXPECT_COMMAND"))
621 {
622 DBusString received;
623
624 _dbus_string_delete_first_word (&line);
625
626 if (!_dbus_string_init (&received))
627 {
628 _dbus_warn ("no mem to allocate string received\n");
629 goto out;
630 }
631
632 if (!_dbus_string_pop_line (&from_auth, &received))
633 {
634 _dbus_warn ("no line popped from the DBusAuth being tested, expected command %s on line %d\n",
635 _dbus_string_get_const_data (&line), line_no);
636 _dbus_string_free (&received);
637 goto out;
638 }
639
640 if (!same_first_word (&received, &line))
641 {
642 _dbus_warn ("line %d expected command '%s' and got '%s'\n",
643 line_no,
644 _dbus_string_get_const_data (&line),
645 _dbus_string_get_const_data (&received));
646 _dbus_string_free (&received);
647 goto out;
648 }
649
650 _dbus_string_free (&received);
651 }
652 else if (_dbus_string_starts_with_c_str (&line,
653 "EXPECT_UNUSED"))
654 {
655 DBusString expected;
656 const DBusString *unused;
657
658 _dbus_string_delete_first_word (&line);
659
660 if (!_dbus_string_init (&expected))
661 {
662 _dbus_warn ("no mem to allocate string expected\n");
663 goto out;
664 }
665
666 if (!append_quoted_string (&expected, &line))
667 {
668 _dbus_warn ("failed to append quoted string line %d\n",
669 line_no);
670 _dbus_string_free (&expected);
671 goto out;
672 }
673
674 _dbus_auth_get_unused_bytes (auth, &unused);
675
676 if (_dbus_string_equal (&expected, unused))
677 {
678 _dbus_auth_delete_unused_bytes (auth);
679 _dbus_string_free (&expected);
680 }
681 else
682 {
683 _dbus_warn ("Expected unused bytes '%s' and have '%s'\n",
684 _dbus_string_get_const_data (&expected),
685 _dbus_string_get_const_data (unused));
686 _dbus_string_free (&expected);
687 goto out;
688 }
689 }
690 else if (_dbus_string_starts_with_c_str (&line,
691 "EXPECT_HAVE_NO_CREDENTIALS"))
692 {
693 DBusCredentials *authorized_identity;
694
695 authorized_identity = _dbus_auth_get_identity (auth);
696 if (!_dbus_credentials_are_anonymous (authorized_identity))
697 {
698 _dbus_warn ("Expected anonymous login or failed login, but some credentials were authorized\n");
699 goto out;
700 }
701 }
702 else if (_dbus_string_starts_with_c_str (&line,
703 "EXPECT_HAVE_SOME_CREDENTIALS"))
704 {
705 DBusCredentials *authorized_identity;
706
707 authorized_identity = _dbus_auth_get_identity (auth);
708 if (_dbus_credentials_are_anonymous (authorized_identity))
709 {
710 _dbus_warn ("Expected to have some credentials, but we don't\n");
711 goto out;
712 }
713 }
714 else if (_dbus_string_starts_with_c_str (&line,
715 "EXPECT"))
716 {
717 DBusString expected;
718
719 _dbus_string_delete_first_word (&line);
720
721 if (!_dbus_string_init (&expected))
722 {
723 _dbus_warn ("no mem to allocate string expected\n");
724 goto out;
725 }
726
727 if (!append_quoted_string (&expected, &line))
728 {
729 _dbus_warn ("failed to append quoted string line %d\n",
730 line_no);
731 _dbus_string_free (&expected);
732 goto out;
733 }
734
735 if (_dbus_string_equal_len (&expected, &from_auth,
736 _dbus_string_get_length (&expected)))
737 {
738 _dbus_string_delete (&from_auth, 0,
739 _dbus_string_get_length (&expected));
740 _dbus_string_free (&expected);
741 }
742 else
743 {
744 _dbus_warn ("Expected exact string '%s' and have '%s'\n",
745 _dbus_string_get_const_data (&expected),
746 _dbus_string_get_const_data (&from_auth));
747 _dbus_string_free (&expected);
748 goto out;
749 }
750 }
751 else
752 goto parse_failed;
753
754 goto next_iteration; /* skip parse_failed */
755
756 parse_failed:
757 {
758 _dbus_warn ("couldn't process line %d \"%s\"\n",
759 line_no, _dbus_string_get_const_data (&line));
760 goto out;
761 }
762 }
763
764 if (auth == NULL)
765 {
766 _dbus_warn ("Auth script is bogus, did not even have CLIENT or SERVER\n");
767 goto out;
768 }
769 else if (state == DBUS_AUTH_STATE_AUTHENTICATED)
770 {
771 const DBusString *unused;
772
773 _dbus_auth_get_unused_bytes (auth, &unused);
774
775 if (_dbus_string_get_length (unused) > 0)
776 {
777 _dbus_warn ("did not expect unused bytes (scripts must specify explicitly if they are expected)\n");
778 goto out;
779 }
780 }
781
782 if (_dbus_string_get_length (&from_auth) > 0)
783 {
784 _dbus_warn ("script did not have EXPECT_ statements for all the data received from the DBusAuth\n");
785 _dbus_warn ("Leftover data: %s\n", _dbus_string_get_const_data (&from_auth));
786 goto out;
787 }
788
789 retval = TRUE;
790
791 out:
792 if (auth)
793 _dbus_auth_unref (auth);
794
795 _dbus_string_free (&file);
796 _dbus_string_free (&line);
797 _dbus_string_free (&from_auth);
798
799 return retval;
800 }
801
803 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */
_dbus_string_append
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
Definition: dbus-string.c:918
DBusError::message
const char * message
public error message field
Definition: dbus-errors.h:51
_dbus_auth_delete_unused_bytes
void _dbus_auth_delete_unused_bytes(DBusAuth *auth)
Gets rid of unused bytes returned by _dbus_auth_get_unused_bytes() after we've gotten them and succes...
Definition: dbus-auth.c:2574
NULL
#define NULL
A null pointer, defined appropriately for C or C++.
DBusCredentials
Definition: dbus-credentials.c:48
_dbus_auth_get_unused_bytes
void _dbus_auth_get_unused_bytes(DBusAuth *auth, const DBusString **str)
Returns leftover bytes that were not used as part of the auth conversation.
Definition: dbus-auth.c:2557
_dbus_string_equal
dbus_bool_t _dbus_string_equal(const DBusString *a, const DBusString *b)
Tests two DBusString for equality.
Definition: dbus-string.c:1995
_dbus_string_hex_encode
dbus_bool_t _dbus_string_hex_encode(const DBusString *source, int start, DBusString *dest, int insert_at)
Encodes a string in hex, the way MD5 and SHA-1 are usually encoded.
Definition: dbus-string.c:2241
_dbus_string_starts_with_c_str
dbus_bool_t _dbus_string_starts_with_c_str(const DBusString *a, const char *c_str)
Checks whether a string starts with the given C string.
Definition: dbus-string.c:2170
_dbus_auth_set_context
dbus_bool_t _dbus_auth_set_context(DBusAuth *auth, const DBusString *context)
Sets the "authentication context" which scopes cookies with the DBUS_COOKIE_SHA1 auth mechanism for e...
Definition: dbus-auth.c:2774
DBUS_ERROR_INIT
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack.
Definition: dbus-errors.h:62
_dbus_auth_return_buffer
void _dbus_auth_return_buffer(DBusAuth *auth, DBusString *buffer)
Returns a buffer with new data read into it.
Definition: dbus-auth.c:2538
_dbus_auth_do_work
DBusAuthState _dbus_auth_do_work(DBusAuth *auth)
Analyzes buffered input and moves the auth conversation forward, returning the new state of the auth ...
Definition: dbus-auth.c:2431
dbus_error_free
void dbus_error_free(DBusError *error)
Frees an error that's been set (or just initialized), then reinitializes the error as in dbus_error_i...
Definition: dbus-errors.c:211
_dbus_auth_set_mechanisms
dbus_bool_t _dbus_auth_set_mechanisms(DBusAuth *auth, const char **mechanisms)
Sets an array of authentication mechanism names that we are willing to use.
Definition: dbus-auth.c:2396
_dbus_string_init
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
_dbus_append_user_from_current_process
dbus_bool_t _dbus_append_user_from_current_process(DBusString *str)
Append to the string the identity we would like to have when we authenticate, on UNIX this is the cur...
Definition: dbus-sysdeps-unix.c:2398
_dbus_string_copy
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that's copied to the d...
Definition: dbus-string.c:1265
DBUS_PID_UNSET
#define DBUS_PID_UNSET
an invalid PID used to represent an uninitialized dbus_pid_t field
Definition: dbus-sysdeps.h:103
_dbus_string_find
dbus_bool_t _dbus_string_find(const DBusString *str, int start, const char *substr, int *found)
Finds the given substring in the string, returning TRUE and filling in the byte index where the subst...
Definition: dbus-string.c:1586
DBUS_UID_UNSET
#define DBUS_UID_UNSET
an invalid UID used to represent an uninitialized dbus_uid_t field
Definition: dbus-sysdeps.h:105
dbus_pid_t
unsigned long dbus_pid_t
A process ID.
Definition: dbus-sysdeps.h:96
_dbus_auth_get_identity
DBusCredentials * _dbus_auth_get_identity(DBusAuth *auth)
Gets the identity we authorized the client as.
Definition: dbus-auth.c:2731
_dbus_auth_get_buffer
void _dbus_auth_get_buffer(DBusAuth *auth, DBusString **buffer)
Get a buffer to be used for reading bytes from the peer we're conversing with.
Definition: dbus-auth.c:2520
dbus_malloc
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
Definition: dbus-memory.c:461
dbus_new0
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
Definition: dbus-memory.h:59
_dbus_credentials_are_anonymous
dbus_bool_t _dbus_credentials_are_anonymous(DBusCredentials *credentials)
Checks whether a credentials object contains a user identity.
Definition: dbus-credentials.c:361
_dbus_auth_bytes_sent
void _dbus_auth_bytes_sent(DBusAuth *auth, int bytes_sent)
Notifies the auth conversation object that the given number of bytes of the outgoing buffer have been...
Definition: dbus-auth.c:2500
DBusString
Definition: dbus-string.h:42
DBusAuth
Internal members of DBusAuth.
Definition: dbus-auth.c:153
dbus_bool_t
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
_dbus_string_init_const
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
Definition: dbus-string.c:190
_dbus_string_skip_blank
void _dbus_string_skip_blank(const DBusString *str, int start, int *end)
Skips blanks from start, storing the first non-blank in *end (blank is space or tab).
Definition: dbus-string.c:1785
_dbus_credentials_new_from_current_process
DBusCredentials * _dbus_credentials_new_from_current_process(void)
Creates a new object with credentials (user ID and process ID) from the current process.
Definition: dbus-credentials.c:93
_dbus_auth_server_new
DBusAuth * _dbus_auth_server_new(const DBusString *guid)
Creates a new auth conversation object for the server side.
Definition: dbus-auth.c:2247
_dbus_string_pop_line
dbus_bool_t _dbus_string_pop_line(DBusString *source, DBusString *dest)
Assigns a newline-terminated or \r\n-terminated line from the front of the string to the given dest s...
Definition: dbus-string.c:1891
_dbus_auth_ref
DBusAuth * _dbus_auth_ref(DBusAuth *auth)
Increments the refcount of an auth object.
Definition: dbus-auth.c:2331
_dbus_warn
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
Definition: dbus-internals.c:230
_dbus_string_delete
void _dbus_string_delete(DBusString *str, int start, int len)
Deletes a segment of a DBusString with length len starting at start.
Definition: dbus-string.c:1175
DBusError
Object representing an exception.
Definition: dbus-errors.h:48
_dbus_string_equal_len
dbus_bool_t _dbus_string_equal_len(const DBusString *a, const DBusString *b, int len)
Tests two DBusString for equality up to the given length.
Definition: dbus-string.c:2038
_dbus_string_append_byte
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory.
Definition: dbus-string.c:1139
_dbus_string_free
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:242
TRUE
#define TRUE
Expands to "1".
_dbus_assert_not_reached
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
Definition: dbus-internals.h:145
_dbus_credentials_add_pid
dbus_bool_t _dbus_credentials_add_pid(DBusCredentials *credentials, dbus_pid_t pid)
Add a UNIX process ID to the credentials.
Definition: dbus-credentials.c:149
_dbus_string_find_blank
dbus_bool_t _dbus_string_find_blank(const DBusString *str, int start, int *found)
Finds a blank (space or tab) in the string.
Definition: dbus-string.c:1747
_dbus_auth_set_credentials
dbus_bool_t _dbus_auth_set_credentials(DBusAuth *auth, DBusCredentials *credentials)
Sets credentials received via reliable means from the operating system.
Definition: dbus-auth.c:2713
_dbus_credentials_new
DBusCredentials * _dbus_credentials_new(void)
Creates a new credentials object.
Definition: dbus-credentials.c:70
dbus_free_string_array
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
Definition: dbus-memory.c:749
_dbus_auth_unref
void _dbus_auth_unref(DBusAuth *auth)
Decrements the refcount of an auth object.
Definition: dbus-auth.c:2346
_dbus_auth_get_bytes_to_send
dbus_bool_t _dbus_auth_get_bytes_to_send(DBusAuth *auth, const DBusString **str)
Gets bytes that need to be sent to the peer we're conversing with.
Definition: dbus-auth.c:2475
_dbus_file_get_contents
dbus_bool_t _dbus_file_get_contents(DBusString *str, const DBusString *filename, DBusError *error)
Appends the contents of the given file to the string, returning error code.
Definition: dbus-file-unix.c:55
_dbus_credentials_unref
void _dbus_credentials_unref(DBusCredentials *credentials)
Decrement refcount on credentials.
Definition: dbus-credentials.c:128
FALSE
#define FALSE
Expands to "0".
_dbus_credentials_add_unix_uid
dbus_bool_t _dbus_credentials_add_unix_uid(DBusCredentials *credentials, dbus_uid_t uid)
Add a UNIX user ID to the credentials.
Definition: dbus-credentials.c:164
dbus_uid_t
unsigned long dbus_uid_t
A user ID.
Definition: dbus-sysdeps.h:98
_dbus_auth_client_new
DBusAuth * _dbus_auth_client_new(void)
Creates a new auth conversation object for the client side.
Definition: dbus-auth.c:2293