D-Bus 1.12.20
dbus-userdb-util.c
1/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2/* dbus-userdb-util.c Would be in dbus-userdb.c, but not used in libdbus
3 *
4 * Copyright (C) 2003, 2004, 2005 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#include <unistd.h>
25#define DBUS_USERDB_INCLUDES_PRIVATE 1
26#include "dbus-userdb.h"
27#include "dbus-test.h"
28#include "dbus-internals.h"
29#include "dbus-protocol.h"
30#include <string.h>
31
32#ifdef HAVE_SYSTEMD
33#include <systemd/sd-login.h>
34#endif
35
41static DBusGroupInfo *
42_dbus_group_info_ref (DBusGroupInfo *info)
43{
44 _dbus_assert (info->refcount > 0);
45 _dbus_assert (info->refcount < SIZE_MAX);
46 info->refcount++;
47 return info;
48}
49
59 DBusError *error)
60{
61
62 DBusUserDatabase *db;
63 const DBusUserInfo *info;
64 dbus_bool_t result = FALSE;
65
66#ifdef HAVE_SYSTEMD
67 /* check if we have logind */
68 if (access ("/run/systemd/seats/", F_OK) >= 0)
69 {
70 int r;
71
72 /* Check whether this user is logged in on at least one physical
73 seat */
74 r = sd_uid_get_seats (uid, 0, NULL);
75 if (r < 0)
76 {
78 "Failed to determine seats of user \"" DBUS_UID_FORMAT "\": %s",
79 uid,
80 _dbus_strerror (-r));
81 return FALSE;
82 }
83
84 return (r > 0);
85 }
86#endif
87
88#ifdef HAVE_CONSOLE_OWNER_FILE
89
90 DBusString f;
91 DBusStat st;
92
93 if (!_dbus_string_init (&f))
94 {
95 _DBUS_SET_OOM (error);
96 return FALSE;
97 }
98
99 if (!_dbus_string_append(&f, DBUS_CONSOLE_OWNER_FILE))
100 {
102 _DBUS_SET_OOM (error);
103 return FALSE;
104 }
105
106 if (_dbus_stat(&f, &st, NULL) && (st.uid == uid))
107 {
109 return TRUE;
110 }
111
113
114#endif /* HAVE_CONSOLE_OWNER_FILE */
115
117 {
118 _DBUS_SET_OOM (error);
119 return FALSE;
120 }
121
123 if (db == NULL)
124 {
125 dbus_set_error (error, DBUS_ERROR_FAILED, "Could not get system database.");
127 return FALSE;
128 }
129
130 /* TPTD: this should be cache-safe, we've locked the DB and
131 _dbus_user_at_console doesn't pass it on. */
132 info = _dbus_user_database_lookup (db, uid, NULL, error);
133
134 if (info == NULL)
135 {
137 return FALSE;
138 }
139
140 result = _dbus_user_at_console (info->username, error);
141
143
144 return result;
145}
146
156 dbus_uid_t *uid)
157{
158 return _dbus_get_user_id_and_primary_group (username, uid, NULL);
159}
160
170 dbus_gid_t *gid)
171{
172 DBusUserDatabase *db;
173 const DBusGroupInfo *info;
174
175 /* FIXME: this can't distinguish ENOMEM from other errors */
177 return FALSE;
178
180 if (db == NULL)
181 {
183 return FALSE;
184 }
185
186 if (!_dbus_user_database_get_groupname (db, groupname,
187 &info, NULL))
188 {
190 return FALSE;
191 }
192
193 *gid = info->gid;
194
196 return TRUE;
197}
198
209 dbus_uid_t *uid_p,
210 dbus_gid_t *gid_p)
211{
212 DBusUserDatabase *db;
213 const DBusUserInfo *info;
214
215 /* FIXME: this can't distinguish ENOMEM from other errors */
217 return FALSE;
218
220 if (db == NULL)
221 {
223 return FALSE;
224 }
225
226 if (!_dbus_user_database_get_username (db, username,
227 &info, NULL))
228 {
230 return FALSE;
231 }
232
233 if (uid_p)
234 *uid_p = info->uid;
235 if (gid_p)
236 *gid_p = info->primary_gid;
237
239 return TRUE;
240}
241
254const DBusGroupInfo *
256 dbus_gid_t gid,
257 const DBusString *groupname,
258 DBusError *error)
259{
260 DBusGroupInfo *info;
261
262 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
263
264 /* See if the group is really a number */
265 if (gid == DBUS_UID_UNSET)
266 {
267 unsigned long n;
268
269 if (_dbus_is_a_number (groupname, &n))
270 gid = n;
271 }
272
273 if (gid != DBUS_GID_UNSET)
274 info = _dbus_hash_table_lookup_uintptr (db->groups, gid);
275 else
276 info = _dbus_hash_table_lookup_string (db->groups_by_name,
277 _dbus_string_get_const_data (groupname));
278 if (info)
279 {
280 _dbus_verbose ("Using cache for GID "DBUS_GID_FORMAT" information\n",
281 info->gid);
282 return info;
283 }
284 else
285 {
286 if (gid != DBUS_GID_UNSET)
287 _dbus_verbose ("No cache for GID "DBUS_GID_FORMAT"\n",
288 gid);
289 else
290 _dbus_verbose ("No cache for groupname \"%s\"\n",
291 _dbus_string_get_const_data (groupname));
292
293 info = dbus_new0 (DBusGroupInfo, 1);
294 if (info == NULL)
295 {
297 return NULL;
298 }
299 info->refcount = 1;
300
301 if (gid != DBUS_GID_UNSET)
302 {
303 if (!_dbus_group_info_fill_gid (info, gid, error))
304 {
305 _DBUS_ASSERT_ERROR_IS_SET (error);
307 return NULL;
308 }
309 }
310 else
311 {
312 if (!_dbus_group_info_fill (info, groupname, error))
313 {
314 _DBUS_ASSERT_ERROR_IS_SET (error);
316 return NULL;
317 }
318 }
319
320 /* don't use these past here */
321 gid = DBUS_GID_UNSET;
322 groupname = NULL;
323
324 if (_dbus_hash_table_insert_uintptr (db->groups, info->gid, info))
325 {
326 _dbus_group_info_ref (info);
327 }
328 else
329 {
332 return NULL;
333 }
334
335
336 if (_dbus_hash_table_insert_string (db->groups_by_name,
337 info->groupname,
338 info))
339 {
340 _dbus_group_info_ref (info);
341 }
342 else
343 {
344 _dbus_hash_table_remove_uintptr (db->groups, info->gid);
347 return NULL;
348 }
349
350 /* Release the original reference */
352
353 /* Return a borrowed reference to the DBusGroupInfo owned by the
354 * two hash tables */
355 return info;
356 }
357}
358
359
372 const DBusString *groupname,
373 const DBusGroupInfo **info,
374 DBusError *error)
375{
376 *info = _dbus_user_database_lookup_group (db, DBUS_GID_UNSET, groupname, error);
377 return *info != NULL;
378}
379
391_dbus_user_database_get_gid (DBusUserDatabase *db,
392 dbus_gid_t gid,
393 const DBusGroupInfo **info,
394 DBusError *error)
395{
396 *info = _dbus_user_database_lookup_group (db, gid, NULL, error);
397 return *info != NULL;
398}
399
400
413 dbus_gid_t **group_ids,
414 int *n_group_ids)
415{
416 DBusUserDatabase *db;
417 const DBusUserInfo *info;
418 *group_ids = NULL;
419 *n_group_ids = 0;
420
421 /* FIXME: this can't distinguish ENOMEM from other errors */
423 return FALSE;
424
426 if (db == NULL)
427 {
429 return FALSE;
430 }
431
432 if (!_dbus_user_database_get_uid (db, uid,
433 &info, NULL))
434 {
436 return FALSE;
437 }
438
439 _dbus_assert (info->uid == uid);
440
441 if (info->n_group_ids > 0)
442 {
443 *group_ids = dbus_new (dbus_gid_t, info->n_group_ids);
444 if (*group_ids == NULL)
445 {
447 return FALSE;
448 }
449
450 *n_group_ids = info->n_group_ids;
451
452 memcpy (*group_ids, info->group_ids, info->n_group_ids * sizeof (dbus_gid_t));
453 }
454
456 return TRUE;
457}
460#ifdef DBUS_ENABLE_EMBEDDED_TESTS
461#include <stdio.h>
462
469_dbus_userdb_test (const char *test_data_dir)
470{
471 const DBusString *username;
472 const DBusString *homedir;
473 dbus_uid_t uid;
474 unsigned long *group_ids;
475 int n_group_ids, i;
476 DBusError error;
477
479 _dbus_assert_not_reached ("didn't get username");
480
482 _dbus_assert_not_reached ("didn't get homedir");
483
484 if (!_dbus_get_user_id (username, &uid))
485 _dbus_assert_not_reached ("didn't get uid");
486
487 if (!_dbus_groups_from_uid (uid, &group_ids, &n_group_ids))
488 _dbus_assert_not_reached ("didn't get groups");
489
490 printf (" Current user: %s homedir: %s gids:",
491 _dbus_string_get_const_data (username),
492 _dbus_string_get_const_data (homedir));
493
494 for (i=0; i<n_group_ids; i++)
495 printf(" %ld", group_ids[i]);
496
497 printf ("\n");
498
499 dbus_error_init (&error);
500 printf ("Is Console user: %i\n",
501 _dbus_is_console_user (uid, &error));
502 printf ("Invocation was OK: %s\n", error.message ? error.message : "yes");
503 dbus_error_free (&error);
504 printf ("Is Console user 4711: %i\n",
505 _dbus_is_console_user (4711, &error));
506 printf ("Invocation was OK: %s\n", error.message ? error.message : "yes");
507 dbus_error_free (&error);
508
509 dbus_free (group_ids);
510
511 return TRUE;
512}
513#endif /* DBUS_ENABLE_EMBEDDED_TESTS */
void dbus_error_init(DBusError *error)
Initializes a DBusError structure.
Definition: dbus-errors.c:188
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
Definition: dbus-errors.c:354
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_bool_t _dbus_hash_table_remove_uintptr(DBusHashTable *table, uintptr_t key)
Removes the hash entry for the given key.
Definition: dbus-hash.c:1189
dbus_bool_t _dbus_hash_table_insert_string(DBusHashTable *table, char *key, void *value)
Creates a hash entry with the given key and value.
Definition: dbus-hash.c:1224
void * _dbus_hash_table_lookup_uintptr(DBusHashTable *table, uintptr_t key)
Looks up the value for a given integer in a hash table of type DBUS_HASH_UINTPTR.
Definition: dbus-hash.c:1109
void * _dbus_hash_table_lookup_string(DBusHashTable *table, const char *key)
Looks up the value for a given string in a hash table of type DBUS_HASH_STRING.
Definition: dbus-hash.c:1059
dbus_bool_t _dbus_hash_table_insert_uintptr(DBusHashTable *table, uintptr_t key, void *value)
Creates a hash entry with the given key and value.
Definition: dbus-hash.c:1299
dbus_bool_t _dbus_stat(const DBusString *filename, DBusStat *statbuf, DBusError *error)
stat() wrapper.
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
dbus_bool_t _dbus_user_database_lock_system(void)
Locks global system user database.
Definition: dbus-userdb.c:343
dbus_bool_t _dbus_homedir_from_current_process(const DBusString **homedir)
Gets homedir of user owning current process.
Definition: dbus-userdb.c:432
dbus_bool_t _dbus_user_at_console(const char *username, DBusError *error)
Checks if user is at the console.
const char * _dbus_error_from_errno(int error_number)
Converts a UNIX errno, or Windows errno or WinSock error value into a DBusError name.
Definition: dbus-sysdeps.c:592
void _dbus_user_database_unlock_system(void)
Unlocks global system user database.
Definition: dbus-userdb.c:360
dbus_bool_t _dbus_user_database_get_uid(DBusUserDatabase *db, dbus_uid_t uid, const DBusUserInfo **info, DBusError *error)
Gets the user information for the given UID, returned user info should not be freed.
Definition: dbus-userdb.c:704
dbus_bool_t _dbus_user_database_get_gid(DBusUserDatabase *db, dbus_gid_t gid, const DBusGroupInfo **info, DBusError *error)
Gets the user information for the given GID, returned group info should not be freed.
dbus_bool_t _dbus_get_group_id(const DBusString *groupname, dbus_gid_t *gid)
Gets group ID given groupname.
void _dbus_group_info_unref(DBusGroupInfo *info)
Decrements the reference count.
Definition: dbus-userdb.c:78
const DBusUserInfo * _dbus_user_database_lookup(DBusUserDatabase *db, dbus_uid_t uid, const DBusString *username, DBusError *error)
Looks up a uid or username in the user database.
Definition: dbus-userdb.c:151
dbus_bool_t _dbus_username_from_current_process(const DBusString **username)
Gets username of user owning current process.
Definition: dbus-userdb.c:408
dbus_bool_t _dbus_is_console_user(dbus_uid_t uid, DBusError *error)
Checks to see if the UID sent in is the console user.
const DBusGroupInfo * _dbus_user_database_lookup_group(DBusUserDatabase *db, dbus_gid_t gid, const DBusString *groupname, DBusError *error)
Looks up a gid or group name in the user database.
dbus_bool_t _dbus_get_user_id_and_primary_group(const DBusString *username, dbus_uid_t *uid_p, dbus_gid_t *gid_p)
Gets user ID and primary group given username.
dbus_bool_t _dbus_user_database_get_username(DBusUserDatabase *db, const DBusString *username, const DBusUserInfo **info, DBusError *error)
Gets the user information for the given username.
Definition: dbus-userdb.c:723
dbus_bool_t _dbus_is_a_number(const DBusString *str, unsigned long *num)
Checks if a given string is actually a number and converts it if it is.
Definition: dbus-userdb.c:126
dbus_bool_t _dbus_user_database_get_groupname(DBusUserDatabase *db, const DBusString *groupname, const DBusGroupInfo **info, DBusError *error)
Gets the user information for the given group name, returned group info should not be freed.
dbus_bool_t _dbus_groups_from_uid(dbus_uid_t uid, dbus_gid_t **group_ids, int *n_group_ids)
Gets all groups corresponding to the given UID.
dbus_bool_t _dbus_get_user_id(const DBusString *username, dbus_uid_t *uid)
Gets user ID given username.
DBusUserDatabase * _dbus_user_database_get_system(void)
Gets the system global user database; must be called with lock held (_dbus_user_database_lock_system(...
Definition: dbus-userdb.c:373
#define NULL
A null pointer, defined appropriately for C or C++.
#define TRUE
Expands to "1".
#define FALSE
Expands to "0".
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:702
#define dbus_new(type, count)
Safe macro for using dbus_malloc().
Definition: dbus-memory.h:57
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
Definition: dbus-memory.h:58
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more.
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation.
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:935
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:259
dbus_bool_t _dbus_group_info_fill(DBusGroupInfo *info, const DBusString *groupname, DBusError *error)
Initializes the given DBusGroupInfo struct with information about the given group name.
dbus_bool_t _dbus_group_info_fill_gid(DBusGroupInfo *info, dbus_gid_t gid, DBusError *error)
Initializes the given DBusGroupInfo struct with information about the given group ID.
unsigned long dbus_uid_t
A user ID.
Definition: dbus-sysdeps.h:134
unsigned long dbus_gid_t
A group ID.
Definition: dbus-sysdeps.h:136
#define DBUS_UID_UNSET
an invalid UID used to represent an uninitialized dbus_uid_t field
Definition: dbus-sysdeps.h:141
#define DBUS_GID_UNSET
an invalid GID used to represent an uninitialized dbus_gid_t field
Definition: dbus-sysdeps.h:143
#define DBUS_GID_FORMAT
an appropriate printf format for dbus_gid_t
Definition: dbus-sysdeps.h:150
#define DBUS_UID_FORMAT
an appropriate printf format for dbus_uid_t
Definition: dbus-sysdeps.h:148
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
Object representing an exception.
Definition: dbus-errors.h:49
const char * message
public error message field
Definition: dbus-errors.h:51
Information about a UNIX group.
dbus_gid_t gid
GID.
char * groupname
Group name.
size_t refcount
Reference count.
Portable struct with stat() results.
Definition: dbus-sysdeps.h:528
dbus_uid_t uid
User owning file.
Definition: dbus-sysdeps.h:531
Information about a UNIX user.
int n_group_ids
Size of group IDs array.
dbus_uid_t uid
UID.
dbus_gid_t * group_ids
Groups IDs, including above primary group.
char * username
Username.
dbus_gid_t primary_gid
GID.