src/libsystemd-daemon/sd-daemon.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   Copyright 2010 Lennart Poettering
   5
   6   Permission is hereby granted, free of charge, to any person
   7   obtaining a copy of this software and associated documentation files
   8   (the "Software"), to deal in the Software without restriction,
   9   including without limitation the rights to use, copy, modify, merge,
  10   publish, distribute, sublicense, and/or sell copies of the Software,
  11   and to permit persons to whom the Software is furnished to do so,
  12   subject to the following conditions:
  13
  14   The above copyright notice and this permission notice shall be
  15   included in all copies or substantial portions of the Software.
  16
  17   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  21   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  22   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24   SOFTWARE.
  25 ***/
  26
  27 #ifndef _GNU_SOURCE
  28 #  define _GNU_SOURCE
  29 #endif
  30
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <sys/socket.h>
  34 #include <sys/un.h>
  35 #include <fcntl.h>
  36 #include <netinet/in.h>
  37 #include <stdlib.h>
  38 #include <errno.h>
  39 #include <unistd.h>
  40 #include <string.h>
  41 #include <stdarg.h>
  42 #include <stdio.h>
  43 #include <stddef.h>
  44 #include <limits.h>
  45
  46 #if defined(__linux__) && !defined(SD_DAEMON_DISABLE_MQ)
  47 #  include <mqueue.h>
  48 #endif
  49
  50 #include "sd-daemon.h"
  51
  52 #if (__GNUC__ >= 4)
  53 #  ifdef SD_EXPORT_SYMBOLS
  54 /* Export symbols */
  55 #    define _sd_export_ __attribute__ ((visibility("default")))
  56 #  else
  57 /* Don't export the symbols */
  58 #    define _sd_export_ __attribute__ ((visibility("hidden")))
  59 #  endif
  60 #else
  61 #  define _sd_export_
  62 #endif
  63
  64 _sd_export_ int sd_listen_fds(int unset_environment) {
  65
  66 #if defined(DISABLE_SYSTEMD) || !defined(__linux__)
  67         return 0;
  68 #else
  69         int r, fd;
  70         const char *e;
  71         char *p = NULL;
  72         unsigned long l;
  73
  74         e = getenv("LISTEN_PID");
  75         if (!e) {
  76                 r = 0;
  77                 goto finish;
  78         }
  79
  80         errno = 0;
  81         l = strtoul(e, &p, 10);
  82
  83         if (errno > 0) {
  84                 r = -errno;
  85                 goto finish;
  86         }
  87
  88         if (!p || p == e || *p || l <= 0) {
  89                 r = -EINVAL;
  90                 goto finish;
  91         }
  92
  93         /* Is this for us? */
  94         if (getpid() != (pid_t) l) {
  95                 r = 0;
  96                 goto finish;
  97         }
  98
  99         e = getenv("LISTEN_FDS");
 100         if (!e) {
 101                 r = 0;
 102                 goto finish;
 103         }
 104
 105         errno = 0;
 106         l = strtoul(e, &p, 10);
 107
 108         if (errno > 0) {
 109                 r = -errno;
 110                 goto finish;
 111         }
 112
 113         if (!p || p == e || *p) {
 114                 r = -EINVAL;
 115                 goto finish;
 116         }
 117
 118         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + (int) l; fd ++) {
 119                 int flags;
 120
 121                 flags = fcntl(fd, F_GETFD);
 122                 if (flags < 0) {
 123                         r = -errno;
 124                         goto finish;
 125                 }
 126
 127                 if (flags & FD_CLOEXEC)
 128                         continue;
 129
 130                 if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) {
 131                         r = -errno;
 132                         goto finish;
 133                 }
 134         }
 135
 136         r = (int) l;
 137
 138 finish:
 139         if (unset_environment) {
 140                 unsetenv("LISTEN_PID");
 141                 unsetenv("LISTEN_FDS");
 142         }
 143
 144         return r;
 145 #endif
 146 }
 147
 148 _sd_export_ int sd_is_fifo(int fd, const char *path) {
 149         struct stat st_fd;
 150
 151         if (fd < 0)
 152                 return -EINVAL;
 153
 154         if (fstat(fd, &st_fd) < 0)
 155                 return -errno;
 156
 157         if (!S_ISFIFO(st_fd.st_mode))
 158                 return 0;
 159
 160         if (path) {
 161                 struct stat st_path;
 162
 163                 if (stat(path, &st_path) < 0) {
 164
 165                         if (errno == ENOENT || errno == ENOTDIR)
 166                                 return 0;
 167
 168                         return -errno;
 169                 }
 170
 171                 return
 172                         st_path.st_dev == st_fd.st_dev &&
 173                         st_path.st_ino == st_fd.st_ino;
 174         }
 175
 176         return 1;
 177 }
 178
 179 _sd_export_ int sd_is_special(int fd, const char *path) {
 180         struct stat st_fd;
 181
 182         if (fd < 0)
 183                 return -EINVAL;
 184
 185         if (fstat(fd, &st_fd) < 0)
 186                 return -errno;
 187
 188         if (!S_ISREG(st_fd.st_mode) && !S_ISCHR(st_fd.st_mode))
 189                 return 0;
 190
 191         if (path) {
 192                 struct stat st_path;
 193
 194                 if (stat(path, &st_path) < 0) {
 195
 196                         if (errno == ENOENT || errno == ENOTDIR)
 197                                 return 0;
 198
 199                         return -errno;
 200                 }
 201
 202                 if (S_ISREG(st_fd.st_mode) && S_ISREG(st_path.st_mode))
 203                         return
 204                                 st_path.st_dev == st_fd.st_dev &&
 205                                 st_path.st_ino == st_fd.st_ino;
 206                 else if (S_ISCHR(st_fd.st_mode) && S_ISCHR(st_path.st_mode))
 207                         return st_path.st_rdev == st_fd.st_rdev;
 208                 else
 209                         return 0;
 210         }
 211
 212         return 1;
 213 }
 214
 215 static int sd_is_socket_internal(int fd, int type, int listening) {
 216         struct stat st_fd;
 217
 218         if (fd < 0 || type < 0)
 219                 return -EINVAL;
 220
 221         if (fstat(fd, &st_fd) < 0)
 222                 return -errno;
 223
 224         if (!S_ISSOCK(st_fd.st_mode))
 225                 return 0;
 226
 227         if (type != 0) {
 228                 int other_type = 0;
 229                 socklen_t l = sizeof(other_type);
 230
 231                 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &other_type, &l) < 0)
 232                         return -errno;
 233
 234                 if (l != sizeof(other_type))
 235                         return -EINVAL;
 236
 237                 if (other_type != type)
 238                         return 0;
 239         }
 240
 241         if (listening >= 0) {
 242                 int accepting = 0;
 243                 socklen_t l = sizeof(accepting);
 244
 245                 if (getsockopt(fd, SOL_SOCKET, SO_ACCEPTCONN, &accepting, &l) < 0)
 246                         return -errno;
 247
 248                 if (l != sizeof(accepting))
 249                         return -EINVAL;
 250
 251                 if (!accepting != !listening)
 252                         return 0;
 253         }
 254
 255         return 1;
 256 }
 257
 258 union sockaddr_union {
 259         struct sockaddr sa;
 260         struct sockaddr_in in4;
 261         struct sockaddr_in6 in6;
 262         struct sockaddr_un un;
 263         struct sockaddr_storage storage;
 264 };
 265
 266 _sd_export_ int sd_is_socket(int fd, int family, int type, int listening) {
 267         int r;
 268
 269         if (family < 0)
 270                 return -EINVAL;
 271
 272         r = sd_is_socket_internal(fd, type, listening);
 273         if (r <= 0)
 274                 return r;
 275
 276         if (family > 0) {
 277                 union sockaddr_union sockaddr = {};
 278                 socklen_t l = sizeof(sockaddr);
 279
 280                 if (getsockname(fd, &sockaddr.sa, &l) < 0)
 281                         return -errno;
 282
 283                 if (l < sizeof(sa_family_t))
 284                         return -EINVAL;
 285
 286                 return sockaddr.sa.sa_family == family;
 287         }
 288
 289         return 1;
 290 }
 291
 292 _sd_export_ int sd_is_socket_inet(int fd, int family, int type, int listening, uint16_t port) {
 293         union sockaddr_union sockaddr = {};
 294         socklen_t l = sizeof(sockaddr);
 295         int r;
 296
 297         if (family != 0 && family != AF_INET && family != AF_INET6)
 298                 return -EINVAL;
 299
 300         r = sd_is_socket_internal(fd, type, listening);
 301         if (r <= 0)
 302                 return r;
 303
 304         if (getsockname(fd, &sockaddr.sa, &l) < 0)
 305                 return -errno;
 306
 307         if (l < sizeof(sa_family_t))
 308                 return -EINVAL;
 309
 310         if (sockaddr.sa.sa_family != AF_INET &&
 311             sockaddr.sa.sa_family != AF_INET6)
 312                 return 0;
 313
 314         if (family > 0)
 315                 if (sockaddr.sa.sa_family != family)
 316                         return 0;
 317
 318         if (port > 0) {
 319                 if (sockaddr.sa.sa_family == AF_INET) {
 320                         if (l < sizeof(struct sockaddr_in))
 321                                 return -EINVAL;
 322
 323                         return htons(port) == sockaddr.in4.sin_port;
 324                 } else {
 325                         if (l < sizeof(struct sockaddr_in6))
 326                                 return -EINVAL;
 327
 328                         return htons(port) == sockaddr.in6.sin6_port;
 329                 }
 330         }
 331
 332         return 1;
 333 }
 334
 335 _sd_export_ int sd_is_socket_unix(int fd, int type, int listening, const char *path, size_t length) {
 336         union sockaddr_union sockaddr = {};
 337         socklen_t l = sizeof(sockaddr);
 338         int r;
 339
 340         r = sd_is_socket_internal(fd, type, listening);
 341         if (r <= 0)
 342                 return r;
 343
 344         if (getsockname(fd, &sockaddr.sa, &l) < 0)
 345                 return -errno;
 346
 347         if (l < sizeof(sa_family_t))
 348                 return -EINVAL;
 349
 350         if (sockaddr.sa.sa_family != AF_UNIX)
 351                 return 0;
 352
 353         if (path) {
 354                 if (length == 0)
 355                         length = strlen(path);
 356
 357                 if (length == 0)
 358                         /* Unnamed socket */
 359                         return l == offsetof(struct sockaddr_un, sun_path);
 360
 361                 if (path[0])
 362                         /* Normal path socket */
 363                         return
 364                                 (l >= offsetof(struct sockaddr_un, sun_path) + length + 1) &&
 365                                 memcmp(path, sockaddr.un.sun_path, length+1) == 0;
 366                 else
 367                         /* Abstract namespace socket */
 368                         return
 369                                 (l == offsetof(struct sockaddr_un, sun_path) + length) &&
 370                                 memcmp(path, sockaddr.un.sun_path, length) == 0;
 371         }
 372
 373         return 1;
 374 }
 375
 376 _sd_export_ int sd_is_mq(int fd, const char *path) {
 377 #if !defined(__linux__) || defined(SD_DAEMON_DISABLE_MQ)
 378         return 0;
 379 #else
 380         struct mq_attr attr;
 381
 382         if (fd < 0)
 383                 return -EINVAL;
 384
 385         if (mq_getattr(fd, &attr) < 0)
 386                 return -errno;
 387
 388         if (path) {
 389                 char fpath[PATH_MAX];
 390                 struct stat a, b;
 391
 392                 if (path[0] != '/')
 393                         return -EINVAL;
 394
 395                 if (fstat(fd, &a) < 0)
 396                         return -errno;
 397
 398                 strncpy(stpcpy(fpath, "/dev/mqueue"), path, sizeof(fpath) - 12);
 399                 fpath[sizeof(fpath)-1] = 0;
 400
 401                 if (stat(fpath, &b) < 0)
 402                         return -errno;
 403
 404                 if (a.st_dev != b.st_dev ||
 405                     a.st_ino != b.st_ino)
 406                         return 0;
 407         }
 408
 409         return 1;
 410 #endif
 411 }
 412
 413 _sd_export_ int sd_notify(int unset_environment, const char *state) {
 414 #if defined(DISABLE_SYSTEMD) || !defined(__linux__) || !defined(SOCK_CLOEXEC)
 415         return 0;
 416 #else
 417         int fd = -1, r;
 418         struct msghdr msghdr;
 419         struct iovec iovec;
 420         union sockaddr_union sockaddr;
 421         const char *e;
 422
 423         if (!state) {
 424                 r = -EINVAL;
 425                 goto finish;
 426         }
 427
 428         e = getenv("NOTIFY_SOCKET");
 429         if (!e)
 430                 return 0;
 431
 432         /* Must be an abstract socket, or an absolute path */
 433         if ((e[0] != '@' && e[0] != '/') || e[1] == 0) {
 434                 r = -EINVAL;
 435                 goto finish;
 436         }
 437
 438         fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0);
 439         if (fd < 0) {
 440                 r = -errno;
 441                 goto finish;
 442         }
 443
 444         memset(&sockaddr, 0, sizeof(sockaddr));
 445         sockaddr.sa.sa_family = AF_UNIX;
 446         strncpy(sockaddr.un.sun_path, e, sizeof(sockaddr.un.sun_path));
 447
 448         if (sockaddr.un.sun_path[0] == '@')
 449                 sockaddr.un.sun_path[0] = 0;
 450
 451         memset(&iovec, 0, sizeof(iovec));
 452         iovec.iov_base = (char*) state;
 453         iovec.iov_len = strlen(state);
 454
 455         memset(&msghdr, 0, sizeof(msghdr));
 456         msghdr.msg_name = &sockaddr;
 457         msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + strlen(e);
 458
 459         if (msghdr.msg_namelen > sizeof(struct sockaddr_un))
 460                 msghdr.msg_namelen = sizeof(struct sockaddr_un);
 461
 462         msghdr.msg_iov = &iovec;
 463         msghdr.msg_iovlen = 1;
 464
 465         if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) < 0) {
 466                 r = -errno;
 467                 goto finish;
 468         }
 469
 470         r = 1;
 471
 472 finish:
 473         if (unset_environment)
 474                 unsetenv("NOTIFY_SOCKET");
 475
 476         if (fd >= 0)
 477                 close(fd);
 478
 479         return r;
 480 #endif
 481 }
 482
 483 _sd_export_ int sd_notifyf(int unset_environment, const char *format, ...) {
 484 #if defined(DISABLE_SYSTEMD) || !defined(__linux__)
 485         return 0;
 486 #else
 487         va_list ap;
 488         char *p = NULL;
 489         int r;
 490
 491         va_start(ap, format);
 492         r = vasprintf(&p, format, ap);
 493         va_end(ap);
 494
 495         if (r < 0 || !p)
 496                 return -ENOMEM;
 497
 498         r = sd_notify(unset_environment, p);
 499         free(p);
 500
 501         return r;
 502 #endif
 503 }
 504
 505 _sd_export_ int sd_booted(void) {
 506 #if defined(DISABLE_SYSTEMD) || !defined(__linux__)
 507         return 0;
 508 #else
 509         struct stat st;
 510
 511         /* We test whether the runtime unit file directory has been
 512          * created. This takes place in mount-setup.c, so is
 513          * guaranteed to happen very early during boot. */
 514
 515         if (lstat("/run/systemd/system/", &st) < 0)
 516                 return 0;
 517
 518         return !!S_ISDIR(st.st_mode);
 519 #endif
 520 }