D-Bus  1.12.2
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 
41 static 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  {
101  _dbus_string_free(&f);
102  _DBUS_SET_OOM (error);
103  return FALSE;
104  }
105 
106  if (_dbus_stat(&f, &st, NULL) && (st.uid == uid))
107  {
108  _dbus_string_free(&f);
109  return TRUE;
110  }
111 
112  _dbus_string_free(&f);
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 
155 _dbus_get_user_id (const DBusString *username,
156  dbus_uid_t *uid)
157 {
158  return _dbus_get_user_id_and_primary_group (username, uid, NULL);
159 }
160 
169 _dbus_get_group_id (const DBusString *groupname,
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 
255 _dbus_user_database_lookup_group (DBusUserDatabase *db,
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);
306  _dbus_group_info_unref (info);
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);
315  _dbus_group_info_unref (info);
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  {
331  _dbus_group_info_unref (info);
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);
345  _dbus_group_info_unref (info);
347  return NULL;
348  }
349 
350  /* Release the original reference */
351  _dbus_group_info_unref (info);
352 
353  return info;
354  }
355 }
356 
357 
369 _dbus_user_database_get_groupname (DBusUserDatabase *db,
370  const DBusString *groupname,
371  const DBusGroupInfo **info,
372  DBusError *error)
373 {
374  *info = _dbus_user_database_lookup_group (db, DBUS_GID_UNSET, groupname, error);
375  return *info != NULL;
376 }
377 
389 _dbus_user_database_get_gid (DBusUserDatabase *db,
390  dbus_gid_t gid,
391  const DBusGroupInfo **info,
392  DBusError *error)
393 {
394  *info = _dbus_user_database_lookup_group (db, gid, NULL, error);
395  return *info != NULL;
396 }
397 
398 
411  dbus_gid_t **group_ids,
412  int *n_group_ids)
413 {
414  DBusUserDatabase *db;
415  const DBusUserInfo *info;
416  *group_ids = NULL;
417  *n_group_ids = 0;
418 
419  /* FIXME: this can't distinguish ENOMEM from other errors */
421  return FALSE;
422 
424  if (db == NULL)
425  {
427  return FALSE;
428  }
429 
430  if (!_dbus_user_database_get_uid (db, uid,
431  &info, NULL))
432  {
434  return FALSE;
435  }
436 
437  _dbus_assert (info->uid == uid);
438 
439  if (info->n_group_ids > 0)
440  {
441  *group_ids = dbus_new (dbus_gid_t, info->n_group_ids);
442  if (*group_ids == NULL)
443  {
445  return FALSE;
446  }
447 
448  *n_group_ids = info->n_group_ids;
449 
450  memcpy (*group_ids, info->group_ids, info->n_group_ids * sizeof (dbus_gid_t));
451  }
452 
454  return TRUE;
455 }
458 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
459 #include <stdio.h>
460 
467 _dbus_userdb_test (const char *test_data_dir)
468 {
469  const DBusString *username;
470  const DBusString *homedir;
471  dbus_uid_t uid;
472  unsigned long *group_ids;
473  int n_group_ids, i;
474  DBusError error;
475 
476  if (!_dbus_username_from_current_process (&username))
477  _dbus_assert_not_reached ("didn't get username");
478 
479  if (!_dbus_homedir_from_current_process (&homedir))
480  _dbus_assert_not_reached ("didn't get homedir");
481 
482  if (!_dbus_get_user_id (username, &uid))
483  _dbus_assert_not_reached ("didn't get uid");
484 
485  if (!_dbus_groups_from_uid (uid, &group_ids, &n_group_ids))
486  _dbus_assert_not_reached ("didn't get groups");
487 
488  printf (" Current user: %s homedir: %s gids:",
489  _dbus_string_get_const_data (username),
490  _dbus_string_get_const_data (homedir));
491 
492  for (i=0; i<n_group_ids; i++)
493  printf(" %ld", group_ids[i]);
494 
495  printf ("\n");
496 
497  dbus_error_init (&error);
498  printf ("Is Console user: %i\n",
499  _dbus_is_console_user (uid, &error));
500  printf ("Invocation was OK: %s\n", error.message ? error.message : "yes");
501  dbus_error_free (&error);
502  printf ("Is Console user 4711: %i\n",
503  _dbus_is_console_user (4711, &error));
504  printf ("Invocation was OK: %s\n", error.message ? error.message : "yes");
505  dbus_error_free (&error);
506 
507  dbus_free (group_ids);
508 
509  return TRUE;
510 }
511 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */
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
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
const char * message
public error message field
Definition: dbus-errors.h:51
char * username
Username.
#define NULL
A null pointer, defined appropriately for C or C++.
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
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:702
Portable struct with stat() results.
Definition: dbus-sysdeps.h:501
#define dbus_new(type, count)
Safe macro for using dbus_malloc().
Definition: dbus-memory.h:58
#define DBUS_GID_FORMAT
an appropriate printf format for dbus_gid_t
Definition: dbus-sysdeps.h:124
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_user_database_lock_system(void)
Locks global system user database.
Definition: dbus-userdb.c:341
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.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
void dbus_error_free(DBusError *error)
Frees an error that&#39;s been set (or just initialized), then reinitializes the error as in dbus_error_i...
Definition: dbus-errors.c:211
dbus_gid_t primary_gid
GID.
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_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:702
void _dbus_user_database_unlock_system(void)
Unlocks global system user database.
Definition: dbus-userdb.c:358
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
char * groupname
Group name.
#define DBUS_UID_UNSET
an invalid UID used to represent an uninitialized dbus_uid_t field
Definition: dbus-sysdeps.h:115
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...
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
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:371
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_gid_t * group_ids
Groups IDs, including above primary group.
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_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
#define dbus_new0(type, count)
Safe macro for using dbus_malloc0().
Definition: dbus-memory.h:59
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
int n_group_ids
Size of group IDs array.
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
dbus_uid_t uid
UID.
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...
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_group_id(const DBusString *groupname, dbus_gid_t *gid)
Gets group ID given groupname.
Object representing an exception.
Definition: dbus-errors.h:48
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_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:259
#define DBUS_GID_UNSET
an invalid GID used to represent an uninitialized dbus_gid_t field
Definition: dbus-sysdeps.h:117
#define TRUE
Expands to "1".
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
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_uid_t uid
User owning file.
Definition: dbus-sysdeps.h:505
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more.
#define DBUS_UID_FORMAT
an appropriate printf format for dbus_uid_t
Definition: dbus-sysdeps.h:122
dbus_bool_t _dbus_homedir_from_current_process(const DBusString **homedir)
Gets homedir of user owning current process.
Definition: dbus-userdb.c:430
Information about a UNIX group.
dbus_bool_t _dbus_stat(const DBusString *filename, DBusStat *statbuf, DBusError *error)
stat() wrapper.
dbus_bool_t _dbus_get_user_id(const DBusString *username, dbus_uid_t *uid)
Gets user ID given username.
size_t refcount
Reference count.
void dbus_error_init(DBusError *error)
Initializes a DBusError structure.
Definition: dbus-errors.c:188
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_user_at_console(const char *username, DBusError *error)
Checks if user is at the console.
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation.
#define FALSE
Expands to "0".
dbus_gid_t gid
GID.
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:721
unsigned long dbus_gid_t
A group ID.
Definition: dbus-sysdeps.h:110
unsigned long dbus_uid_t
A user ID.
Definition: dbus-sysdeps.h:108
void _dbus_group_info_unref(DBusGroupInfo *info)
Decrements the reference count.
Definition: dbus-userdb.c:78
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_username_from_current_process(const DBusString **username)
Gets username of user owning current process.
Definition: dbus-userdb.c:406
Information about a UNIX user.