src/shared/utmp-wtmp.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <poll.h>
  23 #include <stddef.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <sys/time.h>
  28 #include <sys/utsname.h>
  29 #include <unistd.h>
  30 #include <utmpx.h>
  31
  32 #include "alloc-util.h"
  33 #include "fd-util.h"
  34 #include "hostname-util.h"
  35 #include "macro.h"
  36 #include "path-util.h"
  37 #include "string-util.h"
  38 #include "terminal-util.h"
  39 #include "time-util.h"
  40 #include "user-util.h"
  41 #include "util.h"
  42 #include "utmp-wtmp.h"
  43
  44 int utmp_get_runlevel(int *runlevel, int *previous) {
  45         struct utmpx *found, lookup = { .ut_type = RUN_LVL };
  46         int r;
  47         const char *e;
  48
  49         assert(runlevel);
  50
  51         /* If these values are set in the environment this takes
  52          * precedence. Presumably, sysvinit does this to work around a
  53          * race condition that would otherwise exist where we'd always
  54          * go to disk and hence might read runlevel data that might be
  55          * very new and does not apply to the current script being
  56          * executed. */
  57
  58         e = getenv("RUNLEVEL");
  59         if (e && e[0] > 0) {
  60                 *runlevel = e[0];
  61
  62                 if (previous) {
  63                         /* $PREVLEVEL seems to be an Upstart thing */
  64
  65                         e = getenv("PREVLEVEL");
  66                         if (e && e[0] > 0)
  67                                 *previous = e[0];
  68                         else
  69                                 *previous = 0;
  70                 }
  71
  72                 return 0;
  73         }
  74
  75         if (utmpxname(_PATH_UTMPX) < 0)
  76                 return -errno;
  77
  78         setutxent();
  79
  80         found = getutxid(&lookup);
  81         if (!found)
  82                 r = -errno;
  83         else {
  84                 int a, b;
  85
  86                 a = found->ut_pid & 0xFF;
  87                 b = (found->ut_pid >> 8) & 0xFF;
  88
  89                 *runlevel = a;
  90                 if (previous)
  91                         *previous = b;
  92
  93                 r = 0;
  94         }
  95
  96         endutxent();
  97
  98         return r;
  99 }
 100
 101 static void init_timestamp(struct utmpx *store, usec_t t) {
 102         assert(store);
 103
 104         if (t <= 0)
 105                 t = now(CLOCK_REALTIME);
 106
 107         store->ut_tv.tv_sec = t / USEC_PER_SEC;
 108         store->ut_tv.tv_usec = t % USEC_PER_SEC;
 109 }
 110
 111 static void init_entry(struct utmpx *store, usec_t t) {
 112         struct utsname uts = {};
 113
 114         assert(store);
 115
 116         init_timestamp(store, t);
 117
 118         if (uname(&uts) >= 0)
 119                 strncpy(store->ut_host, uts.release, sizeof(store->ut_host));
 120
 121         strncpy(store->ut_line, "~", sizeof(store->ut_line));  /* or ~~ ? */
 122         strncpy(store->ut_id, "~~", sizeof(store->ut_id));
 123 }
 124
 125 static int write_entry_utmp(const struct utmpx *store) {
 126         int r;
 127
 128         assert(store);
 129
 130         /* utmp is similar to wtmp, but there is only one entry for
 131          * each entry type resp. user; i.e. basically a key/value
 132          * table. */
 133
 134         if (utmpxname(_PATH_UTMPX) < 0)
 135                 return -errno;
 136
 137         setutxent();
 138
 139         if (!pututxline(store))
 140                 r = -errno;
 141         else
 142                 r = 0;
 143
 144         endutxent();
 145
 146         return r;
 147 }
 148
 149 static int write_entry_wtmp(const struct utmpx *store) {
 150         assert(store);
 151
 152         /* wtmp is a simple append-only file where each entry is
 153         simply appended to the end; i.e. basically a log. */
 154
 155         errno = 0;
 156         updwtmpx(_PATH_WTMPX, store);
 157         return -errno;
 158 }
 159
 160 static int write_utmp_wtmp(const struct utmpx *store_utmp, const struct utmpx *store_wtmp) {
 161         int r, s;
 162
 163         r = write_entry_utmp(store_utmp);
 164         s = write_entry_wtmp(store_wtmp);
 165
 166         if (r >= 0)
 167                 r = s;
 168
 169         /* If utmp/wtmp have been disabled, that's a good thing, hence
 170          * ignore the errors */
 171         if (r == -ENOENT)
 172                 r = 0;
 173
 174         return r;
 175 }
 176
 177 static int write_entry_both(const struct utmpx *store) {
 178         return write_utmp_wtmp(store, store);
 179 }
 180
 181 int utmp_put_shutdown(void) {
 182         struct utmpx store = {};
 183
 184         init_entry(&store, 0);
 185
 186         store.ut_type = RUN_LVL;
 187         strncpy(store.ut_user, "shutdown", sizeof(store.ut_user));
 188
 189         return write_entry_both(&store);
 190 }
 191
 192 int utmp_put_reboot(usec_t t) {
 193         struct utmpx store = {};
 194
 195         init_entry(&store, t);
 196
 197         store.ut_type = BOOT_TIME;
 198         strncpy(store.ut_user, "reboot", sizeof(store.ut_user));
 199
 200         return write_entry_both(&store);
 201 }
 202
 203 _pure_ static const char *sanitize_id(const char *id) {
 204         size_t l;
 205
 206         assert(id);
 207         l = strlen(id);
 208
 209         if (l <= sizeof(((struct utmpx*) NULL)->ut_id))
 210                 return id;
 211
 212         return id + l - sizeof(((struct utmpx*) NULL)->ut_id);
 213 }
 214
 215 int utmp_put_init_process(const char *id, pid_t pid, pid_t sid, const char *line, int ut_type, const char *user) {
 216         struct utmpx store = {
 217                 .ut_type = INIT_PROCESS,
 218                 .ut_pid = pid,
 219                 .ut_session = sid,
 220         };
 221         int r;
 222
 223         assert(id);
 224
 225         init_timestamp(&store, 0);
 226
 227         /* ut_id needs only be nul-terminated if it is shorter than sizeof(ut_id) */
 228         strncpy(store.ut_id, sanitize_id(id), sizeof(store.ut_id));
 229
 230         if (line)
 231                 strncpy(store.ut_line, basename(line), sizeof(store.ut_line));
 232
 233         r = write_entry_both(&store);
 234         if (r < 0)
 235                 return r;
 236
 237         if (IN_SET(ut_type, LOGIN_PROCESS, USER_PROCESS)) {
 238                 store.ut_type = LOGIN_PROCESS;
 239                 r = write_entry_both(&store);
 240                 if (r < 0)
 241                         return r;
 242         }
 243
 244         if (ut_type == USER_PROCESS) {
 245                 store.ut_type = USER_PROCESS;
 246                 strncpy(store.ut_user, user, sizeof(store.ut_user)-1);
 247                 r = write_entry_both(&store);
 248                 if (r < 0)
 249                         return r;
 250         }
 251
 252         return 0;
 253 }
 254
 255 int utmp_put_dead_process(const char *id, pid_t pid, int code, int status) {
 256         struct utmpx lookup = {
 257                 .ut_type = INIT_PROCESS /* looks for DEAD_PROCESS, LOGIN_PROCESS, USER_PROCESS, too */
 258         }, store, store_wtmp, *found;
 259
 260         assert(id);
 261
 262         setutxent();
 263
 264         /* ut_id needs only be nul-terminated if it is shorter than sizeof(ut_id) */
 265         strncpy(lookup.ut_id, sanitize_id(id), sizeof(lookup.ut_id));
 266
 267         found = getutxid(&lookup);
 268         if (!found)
 269                 return 0;
 270
 271         if (found->ut_pid != pid)
 272                 return 0;
 273
 274         memcpy(&store, found, sizeof(store));
 275         store.ut_type = DEAD_PROCESS;
 276         store.ut_exit.e_termination = code;
 277         store.ut_exit.e_exit = status;
 278
 279         zero(store.ut_user);
 280         zero(store.ut_host);
 281         zero(store.ut_tv);
 282
 283         memcpy(&store_wtmp, &store, sizeof(store_wtmp));
 284         /* wtmp wants the current time */
 285         init_timestamp(&store_wtmp, 0);
 286
 287         return write_utmp_wtmp(&store, &store_wtmp);
 288 }
 289
 290
 291 int utmp_put_runlevel(int runlevel, int previous) {
 292         struct utmpx store = {};
 293         int r;
 294
 295         assert(runlevel > 0);
 296
 297         if (previous <= 0) {
 298                 /* Find the old runlevel automatically */
 299
 300                 r = utmp_get_runlevel(&previous, NULL);
 301                 if (r < 0) {
 302                         if (r != -ESRCH)
 303                                 return r;
 304
 305                         previous = 0;
 306                 }
 307         }
 308
 309         if (previous == runlevel)
 310                 return 0;
 311
 312         init_entry(&store, 0);
 313
 314         store.ut_type = RUN_LVL;
 315         store.ut_pid = (runlevel & 0xFF) | ((previous & 0xFF) << 8);
 316         strncpy(store.ut_user, "runlevel", sizeof(store.ut_user));
 317
 318         return write_entry_both(&store);
 319 }
 320
 321 #define TIMEOUT_MSEC 50
 322
 323 static int write_to_terminal(const char *tty, const char *message) {
 324         _cleanup_close_ int fd = -1;
 325         const char *p;
 326         size_t left;
 327         usec_t end;
 328
 329         assert(tty);
 330         assert(message);
 331
 332         fd = open(tty, O_WRONLY|O_NDELAY|O_NOCTTY|O_CLOEXEC);
 333         if (fd < 0 || !isatty(fd))
 334                 return -errno;
 335
 336         p = message;
 337         left = strlen(message);
 338
 339         end = now(CLOCK_MONOTONIC) + TIMEOUT_MSEC*USEC_PER_MSEC;
 340
 341         while (left > 0) {
 342                 ssize_t n;
 343                 struct pollfd pollfd = {
 344                         .fd = fd,
 345                         .events = POLLOUT,
 346                 };
 347                 usec_t t;
 348                 int k;
 349
 350                 t = now(CLOCK_MONOTONIC);
 351
 352                 if (t >= end)
 353                         return -ETIME;
 354
 355                 k = poll(&pollfd, 1, (end - t) / USEC_PER_MSEC);
 356                 if (k < 0)
 357                         return -errno;
 358
 359                 if (k == 0)
 360                         return -ETIME;
 361
 362                 n = write(fd, p, left);
 363                 if (n < 0) {
 364                         if (errno == EAGAIN)
 365                                 continue;
 366
 367                         return -errno;
 368                 }
 369
 370                 assert((size_t) n <= left);
 371
 372                 p += n;
 373                 left -= n;
 374         }
 375
 376         return 0;
 377 }
 378
 379 int utmp_wall(
 380         const char *message,
 381         const char *username,
 382         const char *origin_tty,
 383         bool (*match_tty)(const char *tty, void *userdata),
 384         void *userdata) {
 385
 386         _cleanup_free_ char *text = NULL, *hn = NULL, *un = NULL, *stdin_tty = NULL;
 387         char date[FORMAT_TIMESTAMP_MAX];
 388         struct utmpx *u;
 389         int r;
 390
 391         hn = gethostname_malloc();
 392         if (!hn)
 393                 return -ENOMEM;
 394         if (!username) {
 395                 un = getlogname_malloc();
 396                 if (!un)
 397                         return -ENOMEM;
 398         }
 399
 400         if (!origin_tty) {
 401                 getttyname_harder(STDIN_FILENO, &stdin_tty);
 402                 origin_tty = stdin_tty;
 403         }
 404
 405         if (asprintf(&text,
 406                      "\a\r\n"
 407                      "Broadcast message from %s@%s%s%s (%s):\r\n\r\n"
 408                      "%s\r\n\r\n",
 409                      un ?: username, hn,
 410                      origin_tty ? " on " : "", strempty(origin_tty),
 411                      format_timestamp(date, sizeof(date), now(CLOCK_REALTIME)),
 412                      message) < 0)
 413                 return -ENOMEM;
 414
 415         setutxent();
 416
 417         r = 0;
 418
 419         while ((u = getutxent())) {
 420                 _cleanup_free_ char *buf = NULL;
 421                 const char *path;
 422                 int q;
 423
 424                 if (u->ut_type != USER_PROCESS || u->ut_user[0] == 0)
 425                         continue;
 426
 427                 /* this access is fine, because strlen("/dev/") << 32 (UT_LINESIZE) */
 428                 if (path_startswith(u->ut_line, "/dev/"))
 429                         path = u->ut_line;
 430                 else {
 431                         if (asprintf(&buf, "/dev/%.*s", (int) sizeof(u->ut_line), u->ut_line) < 0)
 432                                 return -ENOMEM;
 433
 434                         path = buf;
 435                 }
 436
 437                 if (!match_tty || match_tty(path, userdata)) {
 438                         q = write_to_terminal(path, text);
 439                         if (q < 0)
 440                                 r = q;
 441                 }
 442         }
 443
 444         return r;
 445 }