src/logind.h

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 #ifndef foologindhfoo
   4 #define foologindhfoo
   5
   6 /***
   7   This file is part of systemd.
   8
   9   Copyright 2011 Lennart Poettering
  10
  11   systemd is free software; you can redistribute it and/or modify it
  12   under the terms of the GNU General Public License as published by
  13   the Free Software Foundation; either version 2 of the License, or
  14   (at your option) any later version.
  15
  16   systemd is distributed in the hope that it will be useful, but
  17   WITHOUT ANY WARRANTY; without even the implied warranty of
  18   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19   General Public License for more details.
  20
  21   You should have received a copy of the GNU General Public License
  22   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  23 ***/
  24
  25 #include <stdbool.h>
  26 #include <inttypes.h>
  27 #include <dbus/dbus.h>
  28 #include <libudev.h>
  29
  30 #include "util.h"
  31 #include "list.h"
  32 #include "hashmap.h"
  33 #include "cgroup-util.h"
  34
  35 /* TODO:
  36  *
  37  * recreate VTs when disallocated
  38  * udev rules
  39  * spawn user systemd
  40  * non-local X11 server
  41  * udev-acl
  42  * reboot/shutdown halt management
  43  * PAM rewrite
  44  */
  45
  46 typedef struct Manager Manager;
  47 typedef struct Device Device;
  48 typedef struct Seat Seat;
  49 typedef struct Session Session;
  50 typedef struct User User;
  51
  52 struct Device {
  53         Manager *manager;
  54
  55         char *sysfs;
  56         Seat *seat;
  57
  58         dual_timestamp timestamp;
  59
  60         LIST_FIELDS(struct Device, devices);
  61 };
  62
  63 struct Seat {
  64         Manager *manager;
  65         char *id;
  66
  67         char *state_file;
  68
  69         LIST_HEAD(Device, devices);
  70
  71         Session *active;
  72         LIST_HEAD(Session, sessions);
  73 };
  74
  75 typedef enum SessionType {
  76         SESSION_TERMINAL,
  77         SESSION_X11,
  78         _SESSION_TYPE_MAX,
  79         _SESSION_TYPE_INVALID = -1
  80 } SessionType;
  81
  82 struct Session {
  83         Manager *manager;
  84
  85         char *id;
  86         SessionType type;
  87
  88         char *state_file;
  89
  90         User *user;
  91
  92         dual_timestamp timestamp;
  93
  94         char *tty;
  95         char *display;
  96
  97         bool remote;
  98         char *remote_host;
  99
 100         int vtnr;
 101         Seat *seat;
 102
 103         pid_t leader;
 104         uint64_t audit_id;
 105
 106         int pipe_fd;
 107
 108         char *cgroup_path;
 109         char **controllers, **reset_controllers;
 110
 111         bool kill_processes;
 112
 113         LIST_FIELDS(Session, sessions_by_user);
 114         LIST_FIELDS(Session, sessions_by_seat);
 115 };
 116
 117 typedef enum UserState {
 118         USER_OFFLINE,
 119         USER_LINGERING,
 120         USER_ONLINE,
 121         USER_ACTIVE,
 122         _USER_STATE_MAX,
 123         _USER_STATE_INVALID = -1
 124 } UserState;
 125
 126 struct User {
 127         Manager *manager;
 128
 129         uid_t uid;
 130         gid_t gid;
 131         char *name;
 132
 133         char *state_file;
 134         char *runtime_path;
 135         char *service;
 136         char *cgroup_path;
 137
 138         Session *display;
 139
 140         dual_timestamp timestamp;
 141
 142         LIST_HEAD(Session, sessions);
 143 };
 144
 145 struct Manager {
 146         DBusConnection *bus;
 147
 148         Hashmap *devices;
 149         Hashmap *seats;
 150         Hashmap *sessions;
 151         Hashmap *users;
 152
 153         struct udev *udev;
 154         struct udev_monitor *udev_monitor;
 155
 156         int udev_fd;
 157         int console_active_fd;
 158         int bus_fd;
 159         int epoll_fd;
 160
 161         int n_autovts;
 162
 163         Seat *vtconsole;
 164
 165         char *cgroup_path;
 166         char **controllers, **reset_controllers;
 167
 168         char **kill_only_users, **kill_exlude_users;
 169
 170         bool kill_user_processes;
 171 };
 172
 173 Device* device_new(Manager *m, const char *sysfs);
 174 void device_free(Device *d);
 175 void device_attach(Device *d, Seat *s);
 176 void device_detach(Device *d);
 177
 178 Seat *seat_new(Manager *m, const char *id);
 179 void seat_free(Seat *s);
 180 int seat_preallocate_vts(Seat *s);
 181 void seat_active_vt_changed(Seat *s, int vtnr);
 182 int seat_apply_acls(Seat *s);
 183 int seat_stop(Seat *s);
 184 int seat_save(Seat *s);
 185 int seat_load(Seat *s);
 186
 187 Session *session_new(Manager *m, User *u, const char *id);
 188 void session_free(Session *s);
 189 int session_activate(Session *s);
 190 bool session_is_active(Session *s);
 191 int session_check_gc(Session *s);
 192 int session_start(Session *s);
 193 int session_stop(Session *s);
 194 int session_save(Session *s);
 195 int session_load(Session *s);
 196
 197 User* user_new(Manager *m, uid_t uid, gid_t gid, const char *name);
 198 void user_free(User *u);
 199 int user_start(User *u);
 200 int user_stop(User *u);
 201 int user_check_gc(User *u);
 202 UserState user_get_state(User *u);
 203 int user_save(User *u);
 204 int user_load(User *u);
 205
 206 Manager *manager_new(void);
 207 void manager_free(Manager *m);
 208 int manager_add_device(Manager *m, const char *sysfs, Device **_device);
 209 int manager_add_seat(Manager *m, const char *id, Seat **_seat);
 210 int manager_add_session(Manager *m, User *u, const char *id, Session **_session);
 211 int manager_add_user(Manager *m, uid_t uid, gid_t gid, const char *name, User **_user);
 212 int manager_add_user_by_name(Manager *m, const char *name, User **_user);
 213 int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user);
 214 int manager_process_device(Manager *m, struct udev_device *d);
 215 int manager_dispatch_udev(Manager *m);
 216 int manager_dispatch_console(Manager *m);
 217 int manager_enumerate_devices(Manager *m);
 218 int manager_enumerate_seats(Manager *m);
 219 int manager_enumerate_sessions(Manager *m);
 220 int manager_enumerate_users(Manager *m);
 221 int manager_start_one_linger_user(Manager *m, const char *user);
 222 int manager_start_linger_users(Manager *m);
 223 int manager_startup(Manager *m);
 224 int manager_run(Manager *m);
 225 int manager_spawn_autovt(Manager *m, int vtnr);
 226
 227 const char* session_type_to_string(SessionType t);
 228 SessionType session_type_from_string(const char *s);
 229
 230 const char* user_state_to_string(UserState s);
 231 UserState user_state_from_string(const char *s);
 232
 233 bool x11_display_is_local(const char *display);
 234
 235 #endif