src/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 <sys/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
  44 #include "sd-daemon.h"
  45
  46 int sd_listen_fds(int unset_environment) {
  47
  48 #if defined(DISABLE_SYSTEMD) || !defined(__linux__)
  49         return 0;
  50 #else
  51         int r, fd;
  52         const char *e;
  53         char *p = NULL;
  54         unsigned long l;
  55
  56         if (!(e = getenv("LISTEN_PID"))) {
  57                 r = 0;
  58                 goto finish;
  59         }
  60
  61         errno = 0;
  62         l = strtoul(e, &p, 10);
  63
  64         if (errno != 0) {
  65                 r = -errno;
  66                 goto finish;
  67         }
  68
  69         if (!p || *p || l <= 0) {
  70                 r = -EINVAL;
  71                 goto finish;
  72         }
  73
  74         /* Is this for us? */
  75         if (getpid() != (pid_t) l) {
  76                 r = 0;
  77                 goto finish;
  78         }
  79
  80         if (!(e = getenv("LISTEN_FDS"))) {
  81                 r = 0;
  82                 goto finish;
  83         }
  84
  85         errno = 0;
  86         l = strtoul(e, &p, 10);
  87
  88         if (errno != 0) {
  89                 r = -errno;
  90                 goto finish;
  91         }
  92
  93         if (!p || *p) {
  94                 r = -EINVAL;
  95                 goto finish;
  96         }
  97
  98         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + (int) l; fd ++) {
  99                 int flags;
 100
 101                 if ((flags = fcntl(fd, F_GETFD)) < 0) {
 102                         r = -errno;
 103                         goto finish;
 104                 }
 105
 106                 if (flags & FD_CLOEXEC)
 107                         continue;
 108
 109                 if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) {
 110                         r = -errno;
 111                         goto finish;
 112                 }
 113         }
 114
 115         r = (int) l;
 116
 117 finish:
 118         if (unset_environment) {
 119                 unsetenv("LISTEN_PID");
 120                 unsetenv("LISTEN_FDS");
 121         }
 122
 123         return r;
 124 #endif
 125 }
 126
 127 int sd_is_fifo(int fd, const char *path) {
 128         struct stat st_fd;
 129
 130         if (fd < 0)
 131                 return -EINVAL;
 132
 133         memset(&st_fd, 0, sizeof(st_fd));
 134         if (fstat(fd, &st_fd) < 0)
 135                 return -errno;
 136
 137         if (!S_ISFIFO(st_fd.st_mode))
 138                 return 0;
 139
 140         if (path) {
 141                 struct stat st_path;
 142
 143                 memset(&st_path, 0, sizeof(st_path));
 144                 if (stat(path, &st_path) < 0) {
 145
 146                         if (errno == ENOENT || errno == ENOTDIR)
 147                                 return 0;
 148
 149                         return -errno;
 150                 }
 151
 152                 return
 153                         st_path.st_dev == st_fd.st_dev &&
 154                         st_path.st_ino == st_fd.st_ino;
 155         }
 156
 157         return 1;
 158 }
 159
 160 static int sd_is_socket_internal(int fd, int type, int listening) {
 161         struct stat st_fd;
 162
 163         if (fd < 0 || type < 0)
 164                 return -EINVAL;
 165
 166         if (fstat(fd, &st_fd) < 0)
 167                 return -errno;
 168
 169         if (!S_ISSOCK(st_fd.st_mode))
 170                 return 0;
 171
 172         if (type != 0) {
 173                 int other_type = 0;
 174                 socklen_t l = sizeof(other_type);
 175
 176                 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &other_type, &l) < 0)
 177                         return -errno;
 178
 179                 if (l != sizeof(other_type))
 180                         return -EINVAL;
 181
 182                 if (other_type != type)
 183                         return 0;
 184         }
 185
 186         if (listening >= 0) {
 187                 int accepting = 0;
 188                 socklen_t l = sizeof(accepting);
 189
 190                 if (getsockopt(fd, SOL_SOCKET, SO_ACCEPTCONN, &accepting, &l) < 0)
 191                         return -errno;
 192
 193                 if (l != sizeof(accepting))
 194                         return -EINVAL;
 195
 196                 if (!accepting != !listening)
 197                         return 0;
 198         }
 199
 200         return 1;
 201 }
 202
 203 union sockaddr_union {
 204         struct sockaddr sa;
 205         struct sockaddr_in in4;
 206         struct sockaddr_in6 in6;
 207         struct sockaddr_un un;
 208         struct sockaddr_storage storage;
 209 };
 210
 211 int sd_is_socket(int fd, int family, int type, int listening) {
 212         int r;
 213
 214         if (family < 0)
 215                 return -EINVAL;
 216
 217         if ((r = sd_is_socket_internal(fd, type, listening)) <= 0)
 218                 return r;
 219
 220         if (family > 0) {
 221                 union sockaddr_union sockaddr;
 222                 socklen_t l;
 223
 224                 memset(&sockaddr, 0, sizeof(sockaddr));
 225                 l = sizeof(sockaddr);
 226
 227                 if (getsockname(fd, &sockaddr.sa, &l) < 0)
 228                         return -errno;
 229
 230                 if (l < sizeof(sa_family_t))
 231                         return -EINVAL;
 232
 233                 return sockaddr.sa.sa_family == family;
 234         }
 235
 236         return 1;
 237 }
 238
 239 int sd_is_socket_inet(int fd, int family, int type, int listening, uint16_t port) {
 240         union sockaddr_union sockaddr;
 241         socklen_t l;
 242         int r;
 243
 244         if (family != 0 && family != AF_INET && family != AF_INET6)
 245                 return -EINVAL;
 246
 247         if ((r = sd_is_socket_internal(fd, type, listening)) <= 0)
 248                 return r;
 249
 250         memset(&sockaddr, 0, sizeof(sockaddr));
 251         l = sizeof(sockaddr);
 252
 253         if (getsockname(fd, &sockaddr.sa, &l) < 0)
 254                 return -errno;
 255
 256         if (l < sizeof(sa_family_t))
 257                 return -EINVAL;
 258
 259         if (sockaddr.sa.sa_family != AF_INET &&
 260             sockaddr.sa.sa_family != AF_INET6)
 261                 return 0;
 262
 263         if (family > 0)
 264                 if (sockaddr.sa.sa_family != family)
 265                         return 0;
 266
 267         if (port > 0) {
 268                 if (sockaddr.sa.sa_family == AF_INET) {
 269                         if (l < sizeof(struct sockaddr_in))
 270                                 return -EINVAL;
 271
 272                         return htons(port) == sockaddr.in4.sin_port;
 273                 } else {
 274                         if (l < sizeof(struct sockaddr_in6))
 275                                 return -EINVAL;
 276
 277                         return htons(port) == sockaddr.in6.sin6_port;
 278                 }
 279         }
 280
 281         return 1;
 282 }
 283
 284 int sd_is_socket_unix(int fd, int type, int listening, const char *path, size_t length) {
 285         union sockaddr_union sockaddr;
 286         socklen_t l;
 287         int r;
 288
 289         if ((r = sd_is_socket_internal(fd, type, listening)) <= 0)
 290                 return r;
 291
 292         memset(&sockaddr, 0, sizeof(sockaddr));
 293         l = sizeof(sockaddr);
 294
 295         if (getsockname(fd, &sockaddr.sa, &l) < 0)
 296                 return -errno;
 297
 298         if (l < sizeof(sa_family_t))
 299                 return -EINVAL;
 300
 301         if (sockaddr.sa.sa_family != AF_UNIX)
 302                 return 0;
 303
 304         if (path) {
 305                 if (length <= 0)
 306                         length = strlen(path);
 307
 308                 if (length <= 0)
 309                         /* Unnamed socket */
 310                         return l == sizeof(sa_family_t);
 311
 312                 if (path[0])
 313                         /* Normal path socket */
 314                         return
 315                                 (l >= sizeof(sa_family_t) + length + 1) &&
 316                                 memcmp(path, sockaddr.un.sun_path, length+1) == 0;
 317                 else
 318                         /* Abstract namespace socket */
 319                         return
 320                                 (l == sizeof(sa_family_t) + length) &&
 321                                 memcmp(path, sockaddr.un.sun_path, length) == 0;
 322         }
 323
 324         return 1;
 325 }
 326
 327 int sd_notify(int unset_environment, const char *state) {
 328 #if defined(DISABLE_SYSTEMD) || !defined(__linux__) || !defined(SOCK_CLOEXEC)
 329         return 0;
 330 #else
 331         int fd = -1, r;
 332         struct msghdr msghdr;
 333         struct iovec iovec;
 334         union sockaddr_union sockaddr;
 335         struct ucred *ucred;
 336         union {
 337                 struct cmsghdr cmsghdr;
 338                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
 339         } control;
 340         const char *e;
 341
 342         if (!state) {
 343                 r = -EINVAL;
 344                 goto finish;
 345         }
 346
 347         if (!(e = getenv("NOTIFY_SOCKET")))
 348                 return 0;
 349
 350         /* Must be an abstract socket, or an absolute path */
 351         if ((e[0] != '@' && e[0] != '/') || e[1] == 0) {
 352                 r = -EINVAL;
 353                 goto finish;
 354         }
 355
 356         if ((fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0) {
 357                 r = -errno;
 358                 goto finish;
 359         }
 360
 361         memset(&sockaddr, 0, sizeof(sockaddr));
 362         sockaddr.sa.sa_family = AF_UNIX;
 363         strncpy(sockaddr.un.sun_path, e, sizeof(sockaddr.un.sun_path));
 364
 365         if (sockaddr.un.sun_path[0] == '@')
 366                 sockaddr.un.sun_path[0] = 0;
 367
 368         memset(&iovec, 0, sizeof(iovec));
 369         iovec.iov_base = (char*) state;
 370         iovec.iov_len = strlen(state);
 371
 372         memset(&control, 0, sizeof(control));
 373         control.cmsghdr.cmsg_level = SOL_SOCKET;
 374         control.cmsghdr.cmsg_type = SCM_CREDENTIALS;
 375         control.cmsghdr.cmsg_len = CMSG_LEN(sizeof(struct ucred));
 376
 377         ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
 378         ucred->pid = getpid();
 379         ucred->uid = getuid();
 380         ucred->gid = getgid();
 381
 382         memset(&msghdr, 0, sizeof(msghdr));
 383         msghdr.msg_name = &sockaddr;
 384         msghdr.msg_namelen = sizeof(sa_family_t) + strlen(e);
 385
 386         if (msghdr.msg_namelen > sizeof(struct sockaddr_un))
 387                 msghdr.msg_namelen = sizeof(struct sockaddr_un);
 388
 389         msghdr.msg_iov = &iovec;
 390         msghdr.msg_iovlen = 1;
 391         msghdr.msg_control = &control;
 392         msghdr.msg_controllen = control.cmsghdr.cmsg_len;
 393
 394         if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) < 0) {
 395                 r = -errno;
 396                 goto finish;
 397         }
 398
 399         r = 1;
 400
 401 finish:
 402         if (unset_environment)
 403                 unsetenv("NOTIFY_SOCKET");
 404
 405         if (fd >= 0)
 406                 close(fd);
 407
 408         return r;
 409 #endif
 410 }
 411
 412 int sd_notifyf(int unset_environment, const char *format, ...) {
 413 #if defined(DISABLE_SYSTEMD) || !defined(__linux__)
 414         return 0;
 415 #else
 416         va_list ap;
 417         char *p = NULL;
 418         int r;
 419
 420         va_start(ap, format);
 421         r = vasprintf(&p, format, ap);
 422         va_end(ap);
 423
 424         if (r < 0 || !p)
 425                 return -ENOMEM;
 426
 427         r = sd_notify(unset_environment, p);
 428         free(p);
 429
 430         return r;
 431 #endif
 432 }
 433
 434 int sd_booted(void) {
 435 #if defined(DISABLE_SYSTEMD) || !defined(__linux__)
 436         return 0;
 437 #else
 438
 439         struct stat a, b;
 440
 441         /* We simply test whether the systemd cgroup hierarchy is
 442          * mounted */
 443
 444         if (lstat("/cgroup", &a) < 0)
 445                 return 0;
 446
 447         if (lstat("/cgroup/systemd", &b) < 0)
 448                 return 0;
 449
 450         return a.st_dev != b.st_dev;
 451 #endif
 452 }