src/shared/utmp-wtmp.c

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