util.c revision 3b63d2d31d0850bd7a81ab9b468218d2c4c461e8
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen/***
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen This file is part of systemd.
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen Copyright 2010 Lennart Poettering
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen systemd is free software; you can redistribute it and/or modify it
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen under the terms of the GNU General Public License as published by
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen the Free Software Foundation; either version 2 of the License, or
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen (at your option) any later version.
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen systemd is distributed in the hope that it will be useful, but
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen WITHOUT ANY WARRANTY; without even the implied warranty of
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen General Public License for more details.
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen You should have received a copy of the GNU General Public License
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen along with systemd; If not, see <http://www.gnu.org/licenses/>.
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen***/
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <assert.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <string.h>
07630cea1f3a845c09309f197ac7c4f11edd3b62Lennart Poettering#include <unistd.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <errno.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <stdlib.h>
07630cea1f3a845c09309f197ac7c4f11edd3b62Lennart Poettering#include <signal.h>
07630cea1f3a845c09309f197ac7c4f11edd3b62Lennart Poettering#include <stdio.h>
07630cea1f3a845c09309f197ac7c4f11edd3b62Lennart Poettering#include <syslog.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <sched.h>
3ffd4af22052963e7a29431721ee204e634bea75Lennart Poettering#include <sys/resource.h>
8b197c3a8a57c3f7c231b39e5660856fd9580c80Auke Kok#include <linux/sched.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <sys/types.h>
07630cea1f3a845c09309f197ac7c4f11edd3b62Lennart Poettering#include <sys/stat.h>
3ffd4af22052963e7a29431721ee204e634bea75Lennart Poettering#include <fcntl.h>
07630cea1f3a845c09309f197ac7c4f11edd3b62Lennart Poettering#include <dirent.h>
07630cea1f3a845c09309f197ac7c4f11edd3b62Lennart Poettering#include <sys/ioctl.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <linux/vt.h>
2b3e18de74ca89b374dd4f7a2c30e5731d347841Karol Lewandowski#include <linux/tiocl.h>
2b3e18de74ca89b374dd4f7a2c30e5731d347841Karol Lewandowski#include <termios.h>
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include <stdarg.h>
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include <sys/inotify.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <sys/poll.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <libgen.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <ctype.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <sys/prctl.h>
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek#include <sys/utsname.h>
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include <pwd.h>
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include <netinet/ip.h>
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include <linux/kd.h>
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include <dlfcn.h>
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include <sys/wait.h>
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include "macro.h"
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include "util.h"
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include "ioprio.h"
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include "missing.h"
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek#include "log.h"
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho#include "strv.h"
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek#include "label.h"
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen#include "exit-status.h"
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
6656aefb42385b468dd96867118d049f945cbf81WaLyong Chobool streq_ptr(const char *a, const char *b) {
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen /* Like streq(), but tries to make sense of NULL pointers */
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho if (a && b)
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek return streq(a, b);
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen if (!a && !b)
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen return true;
fea7838e7e0b2724f5e0bc028121a08b42995045Zbigniew Jędrzejewski-Szmek
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen return false;
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen}
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chenusec_t now(clockid_t clock_id) {
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen struct timespec ts;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert_se(clock_gettime(clock_id, &ts) == 0);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek return timespec_load(&ts);
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek}
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmekdual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(ts);
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen ts->realtime = now(CLOCK_REALTIME);
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen ts->monotonic = now(CLOCK_MONOTONIC);
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen return ts;
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek}
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
03e334a1c7dc8c20c38902aa039440763acc9b17Lennart Poetteringusec_t timespec_load(const struct timespec *ts) {
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(ts);
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen return
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen (usec_t) ts->tv_sec * USEC_PER_SEC +
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen (usec_t) ts->tv_nsec / NSEC_PER_USEC;
fea7838e7e0b2724f5e0bc028121a08b42995045Zbigniew Jędrzejewski-Szmek}
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Chostruct timespec *timespec_store(struct timespec *ts, usec_t u) {
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(ts);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho ts->tv_sec = (time_t) (u / USEC_PER_SEC);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return ts;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho}
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Chousec_t timeval_load(const struct timeval *tv) {
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(tv);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho (usec_t) tv->tv_sec * USEC_PER_SEC +
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho (usec_t) tv->tv_usec;
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek}
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Chostruct timeval *timeval_store(struct timeval *tv, usec_t u) {
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(tv);
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho tv->tv_sec = (time_t) (u / USEC_PER_SEC);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return tv;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho}
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Chobool endswith(const char *s, const char *postfix) {
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho size_t sl, pl;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(s);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(postfix);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho sl = strlen(s);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho pl = strlen(postfix);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho if (pl == 0)
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return true;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho if (sl < pl)
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return false;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return memcmp(s + sl - pl, postfix, pl) == 0;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho}
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Chobool startswith(const char *s, const char *prefix) {
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho size_t sl, pl;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(s);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(prefix);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho sl = strlen(s);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho pl = strlen(prefix);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho if (pl == 0)
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return true;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho if (sl < pl)
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return false;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return memcmp(s, prefix, pl) == 0;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho}
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Chobool startswith_no_case(const char *s, const char *prefix) {
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho size_t sl, pl;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho unsigned i;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(s);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho assert(prefix);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho sl = strlen(s);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho pl = strlen(prefix);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho if (pl == 0)
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return true;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho if (sl < pl)
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return false;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho for(i = 0; i < pl; ++i) {
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho if (tolower(s[i]) != tolower(prefix[i]))
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return false;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho }
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho return true;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho}
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmekbool first_word(const char *s, const char *word) {
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho size_t sl, wl;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek assert(s);
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek assert(word);
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen sl = strlen(s);
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen wl = strlen(word);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek if (sl < wl)
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek return false;
2b3e18de74ca89b374dd4f7a2c30e5731d347841Karol Lewandowski
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen if (wl == 0)
8a188de9e0ea41509beda12084126d7a75ebe86eWaLyong Cho return true;
2b3e18de74ca89b374dd4f7a2c30e5731d347841Karol Lewandowski
2b3e18de74ca89b374dd4f7a2c30e5731d347841Karol Lewandowski if (memcmp(s, word, wl) != 0)
2b3e18de74ca89b374dd4f7a2c30e5731d347841Karol Lewandowski return false;
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek return s[wl] == 0 ||
e49d3c016751c03e544697656e8e596af8a664d7Łukasz Stelmach strchr(WHITESPACE, s[wl]);
e49d3c016751c03e544697656e8e596af8a664d7Łukasz Stelmach}
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmekint close_nointr(int fd) {
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek assert(fd >= 0);
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek for (;;) {
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek int r;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek if ((r = close(fd)) >= 0)
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek return r;
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen if (errno != EINTR)
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen return r;
e53fc357a9bb9d0a5362ccc4246d598cb0febd5eLennart Poettering }
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen}
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chenvoid close_nointr_nofail(int fd) {
8b197c3a8a57c3f7c231b39e5660856fd9580c80Auke Kok int saved_errno = errno;
4c1fc3e404d648c70bd2f50ac50aeac6ece8872eDaniel Mack
8b197c3a8a57c3f7c231b39e5660856fd9580c80Auke Kok /* like close_nointr() but cannot fail, and guarantees errno
23446f01480e1d6f72a03d71f9c67cbf34ddaf3bMichal Schmidt * is unchanged */
8b197c3a8a57c3f7c231b39e5660856fd9580c80Auke Kok
8b197c3a8a57c3f7c231b39e5660856fd9580c80Auke Kok assert_se(close_nointr(fd) == 0);
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen errno = saved_errno;
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen}
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chenvoid close_many(const int fds[], unsigned n_fd) {
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen unsigned i;
6656aefb42385b468dd96867118d049f945cbf81WaLyong Cho
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen for (i = 0; i < n_fd; i++)
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen close_nointr_nofail(fds[i]);
abbacb1defaaecb8d2477685f7bb3fabcf58585bNathaniel Chen}
b9289d4c6e13ec5fb67bfce69c826d93b004da6aPhilippe De Swert
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmekint parse_boolean(const char *v) {
e53fc357a9bb9d0a5362ccc4246d598cb0febd5eLennart Poettering assert(v);
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek
a4783bd17ad96f55b0fe83a50959da13555292bfZbigniew Jędrzejewski-Szmek if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on"))
2b3e18de74ca89b374dd4f7a2c30e5731d347841Karol Lewandowski return 1;
e49d3c016751c03e544697656e8e596af8a664d7Łukasz Stelmach else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off"))
e49d3c016751c03e544697656e8e596af8a664d7Łukasz Stelmach return 0;
2b3e18de74ca89b374dd4f7a2c30e5731d347841Karol Lewandowski
2b3e18de74ca89b374dd4f7a2c30e5731d347841Karol Lewandowski return -EINVAL;
2b3e18de74ca89b374dd4f7a2c30e5731d347841Karol Lewandowski}
ffbd2c4d45787ba5ba85a32db6551efba66a1ee6Nathaniel Chen
int parse_pid(const char *s, pid_t* ret_pid) {
unsigned long ul;
pid_t pid;
int r;
assert(s);
assert(ret_pid);
if ((r = safe_atolu(s, &ul)) < 0)
return r;
pid = (pid_t) ul;
if ((unsigned long) pid != ul)
return -ERANGE;
if (pid <= 0)
return -ERANGE;
*ret_pid = pid;
return 0;
}
int safe_atou(const char *s, unsigned *ret_u) {
char *x = NULL;
unsigned long l;
assert(s);
assert(ret_u);
errno = 0;
l = strtoul(s, &x, 0);
if (!x || *x || errno)
return errno ? -errno : -EINVAL;
if ((unsigned long) (unsigned) l != l)
return -ERANGE;
*ret_u = (unsigned) l;
return 0;
}
int safe_atoi(const char *s, int *ret_i) {
char *x = NULL;
long l;
assert(s);
assert(ret_i);
errno = 0;
l = strtol(s, &x, 0);
if (!x || *x || errno)
return errno ? -errno : -EINVAL;
if ((long) (int) l != l)
return -ERANGE;
*ret_i = (int) l;
return 0;
}
int safe_atollu(const char *s, long long unsigned *ret_llu) {
char *x = NULL;
unsigned long long l;
assert(s);
assert(ret_llu);
errno = 0;
l = strtoull(s, &x, 0);
if (!x || *x || errno)
return errno ? -errno : -EINVAL;
*ret_llu = l;
return 0;
}
int safe_atolli(const char *s, long long int *ret_lli) {
char *x = NULL;
long long l;
assert(s);
assert(ret_lli);
errno = 0;
l = strtoll(s, &x, 0);
if (!x || *x || errno)
return errno ? -errno : -EINVAL;
*ret_lli = l;
return 0;
}
/* Split a string into words. */
char *split(const char *c, size_t *l, const char *separator, char **state) {
char *current;
current = *state ? *state : (char*) c;
if (!*current || *c == 0)
return NULL;
current += strspn(current, separator);
*l = strcspn(current, separator);
*state = current+*l;
return (char*) current;
}
/* Split a string into words, but consider strings enclosed in '' and
* "" as words even if they include spaces. */
char *split_quoted(const char *c, size_t *l, char **state) {
char *current, *e;
bool escaped = false;
current = *state ? *state : (char*) c;
if (!*current || *c == 0)
return NULL;
current += strspn(current, WHITESPACE);
if (*current == '\'') {
current ++;
for (e = current; *e; e++) {
if (escaped)
escaped = false;
else if (*e == '\\')
escaped = true;
else if (*e == '\'')
break;
}
*l = e-current;
*state = *e == 0 ? e : e+1;
} else if (*current == '\"') {
current ++;
for (e = current; *e; e++) {
if (escaped)
escaped = false;
else if (*e == '\\')
escaped = true;
else if (*e == '\"')
break;
}
*l = e-current;
*state = *e == 0 ? e : e+1;
} else {
for (e = current; *e; e++) {
if (escaped)
escaped = false;
else if (*e == '\\')
escaped = true;
else if (strchr(WHITESPACE, *e))
break;
}
*l = e-current;
*state = e;
}
return (char*) current;
}
char **split_path_and_make_absolute(const char *p) {
char **l;
assert(p);
if (!(l = strv_split(p, ":")))
return NULL;
if (!strv_path_make_absolute_cwd(l)) {
strv_free(l);
return NULL;
}
return l;
}
int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
int r;
FILE *f;
char fn[132], line[256], *p;
long unsigned ppid;
assert(pid >= 0);
assert(_ppid);
assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
fn[sizeof(fn)-1] = 0;
if (!(f = fopen(fn, "r")))
return -errno;
if (!(fgets(line, sizeof(line), f))) {
r = -errno;
fclose(f);
return r;
}
fclose(f);
/* Let's skip the pid and comm fields. The latter is enclosed
* in () but does not escape any () in its value, so let's
* skip over it manually */
if (!(p = strrchr(line, ')')))
return -EIO;
p++;
if (sscanf(p, " "
"%*c " /* state */
"%lu ", /* ppid */
&ppid) != 1)
return -EIO;
if ((long unsigned) (pid_t) ppid != ppid)
return -ERANGE;
*_ppid = (pid_t) ppid;
return 0;
}
int write_one_line_file(const char *fn, const char *line) {
FILE *f;
int r;
assert(fn);
assert(line);
if (!(f = fopen(fn, "we")))
return -errno;
if (fputs(line, f) < 0) {
r = -errno;
goto finish;
}
r = 0;
finish:
fclose(f);
return r;
}
int read_one_line_file(const char *fn, char **line) {
FILE *f;
int r;
char t[LINE_MAX], *c;
assert(fn);
assert(line);
if (!(f = fopen(fn, "re")))
return -errno;
if (!(fgets(t, sizeof(t), f))) {
r = -errno;
goto finish;
}
if (!(c = strdup(t))) {
r = -ENOMEM;
goto finish;
}
*line = c;
r = 0;
finish:
fclose(f);
return r;
}
int read_full_file(const char *fn, char **contents) {
FILE *f;
int r;
size_t n, l;
char *buf = NULL;
struct stat st;
if (!(f = fopen(fn, "re")))
return -errno;
if (fstat(fileno(f), &st) < 0) {
r = -errno;
goto finish;
}
n = st.st_size > 0 ? st.st_size : LINE_MAX;
l = 0;
for (;;) {
char *t;
size_t k;
if (!(t = realloc(buf, n+1))) {
r = -ENOMEM;
goto finish;
}
buf = t;
k = fread(buf + l, 1, n - l, f);
if (k <= 0) {
if (ferror(f)) {
r = -errno;
goto finish;
}
break;
}
l += k;
n *= 2;
/* Safety check */
if (n > 4*1024*1024) {
r = -E2BIG;
goto finish;
}
}
if (buf)
buf[l] = 0;
else if (!(buf = calloc(1, 1))) {
r = -errno;
goto finish;
}
*contents = buf;
buf = NULL;
r = 0;
finish:
fclose(f);
free(buf);
return r;
}
int parse_env_file(
const char *fname,
const char *separator, ...) {
int r = 0;
char *contents, *p;
assert(fname);
assert(separator);
if ((r = read_full_file(fname, &contents)) < 0)
return r;
p = contents;
for (;;) {
const char *key = NULL;
p += strspn(p, separator);
p += strspn(p, WHITESPACE);
if (!*p)
break;
if (!strchr(COMMENTS, *p)) {
va_list ap;
char **value;
va_start(ap, separator);
while ((key = va_arg(ap, char *))) {
size_t n;
char *v;
value = va_arg(ap, char **);
n = strlen(key);
if (strncmp(p, key, n) != 0 ||
p[n] != '=')
continue;
p += n + 1;
n = strcspn(p, separator);
if (n >= 2 &&
strchr(QUOTES, p[0]) &&
p[n-1] == p[0])
v = strndup(p+1, n-2);
else
v = strndup(p, n);
if (!v) {
r = -ENOMEM;
va_end(ap);
goto fail;
}
if (v[0] == '\0') {
/* return empty value strings as NULL */
free(v);
v = NULL;
}
free(*value);
*value = v;
p += n;
r ++;
break;
}
va_end(ap);
}
if (!key)
p += strcspn(p, separator);
}
fail:
free(contents);
return r;
}
char *truncate_nl(char *s) {
assert(s);
s[strcspn(s, NEWLINE)] = 0;
return s;
}
int get_process_name(pid_t pid, char **name) {
char *p;
int r;
assert(pid >= 1);
assert(name);
if (asprintf(&p, "/proc/%lu/comm", (unsigned long) pid) < 0)
return -ENOMEM;
r = read_one_line_file(p, name);
free(p);
if (r < 0)
return r;
truncate_nl(*name);
return 0;
}
int get_process_cmdline(pid_t pid, size_t max_length, char **line) {
char *p, *r, *k;
int c;
bool space = false;
size_t left;
FILE *f;
assert(pid >= 1);
assert(max_length > 0);
assert(line);
if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
return -ENOMEM;
f = fopen(p, "r");
free(p);
if (!f)
return -errno;
if (!(r = new(char, max_length))) {
fclose(f);
return -ENOMEM;
}
k = r;
left = max_length;
while ((c = getc(f)) != EOF) {
if (isprint(c)) {
if (space) {
if (left <= 4)
break;
*(k++) = ' ';
left--;
space = false;
}
if (left <= 4)
break;
*(k++) = (char) c;
left--;
} else
space = true;
}
if (left <= 4) {
size_t n = MIN(left-1, 3U);
memcpy(k, "...", n);
k[n] = 0;
} else
*k = 0;
fclose(f);
/* Kernel threads have no argv[] */
if (r[0] == 0) {
char *t;
int h;
free(r);
if ((h = get_process_name(pid, &t)) < 0)
return h;
h = asprintf(&r, "[%s]", t);
free(t);
if (h < 0)
return -ENOMEM;
}
*line = r;
return 0;
}
char *strnappend(const char *s, const char *suffix, size_t b) {
size_t a;
char *r;
if (!s && !suffix)
return strdup("");
if (!s)
return strndup(suffix, b);
if (!suffix)
return strdup(s);
assert(s);
assert(suffix);
a = strlen(s);
if (!(r = new(char, a+b+1)))
return NULL;
memcpy(r, s, a);
memcpy(r+a, suffix, b);
r[a+b] = 0;
return r;
}
char *strappend(const char *s, const char *suffix) {
return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
}
int readlink_malloc(const char *p, char **r) {
size_t l = 100;
assert(p);
assert(r);
for (;;) {
char *c;
ssize_t n;
if (!(c = new(char, l)))
return -ENOMEM;
if ((n = readlink(p, c, l-1)) < 0) {
int ret = -errno;
free(c);
return ret;
}
if ((size_t) n < l-1) {
c[n] = 0;
*r = c;
return 0;
}
free(c);
l *= 2;
}
}
int readlink_and_make_absolute(const char *p, char **r) {
char *target, *k;
int j;
assert(p);
assert(r);
if ((j = readlink_malloc(p, &target)) < 0)
return j;
k = file_in_same_dir(p, target);
free(target);
if (!k)
return -ENOMEM;
*r = k;
return 0;
}
int parent_of_path(const char *path, char **_r) {
const char *e, *a = NULL, *b = NULL, *p;
char *r;
bool slash = false;
assert(path);
assert(_r);
if (!*path)
return -EINVAL;
for (e = path; *e; e++) {
if (!slash && *e == '/') {
a = b;
b = e;
slash = true;
} else if (slash && *e != '/')
slash = false;
}
if (*(e-1) == '/')
p = a;
else
p = b;
if (!p)
return -EINVAL;
if (p == path)
r = strdup("/");
else
r = strndup(path, p-path);
if (!r)
return -ENOMEM;
*_r = r;
return 0;
}
char *file_name_from_path(const char *p) {
char *r;
assert(p);
if ((r = strrchr(p, '/')))
return r + 1;
return (char*) p;
}
bool path_is_absolute(const char *p) {
assert(p);
return p[0] == '/';
}
bool is_path(const char *p) {
return !!strchr(p, '/');
}
char *path_make_absolute(const char *p, const char *prefix) {
char *r;
assert(p);
/* Makes every item in the list an absolute path by prepending
* the prefix, if specified and necessary */
if (path_is_absolute(p) || !prefix)
return strdup(p);
if (asprintf(&r, "%s/%s", prefix, p) < 0)
return NULL;
return r;
}
char *path_make_absolute_cwd(const char *p) {
char *cwd, *r;
assert(p);
/* Similar to path_make_absolute(), but prefixes with the
* current working directory. */
if (path_is_absolute(p))
return strdup(p);
if (!(cwd = get_current_dir_name()))
return NULL;
r = path_make_absolute(p, cwd);
free(cwd);
return r;
}
char **strv_path_make_absolute_cwd(char **l) {
char **s;
/* Goes through every item in the string list and makes it
* absolute. This works in place and won't rollback any
* changes on failure. */
STRV_FOREACH(s, l) {
char *t;
if (!(t = path_make_absolute_cwd(*s)))
return NULL;
free(*s);
*s = t;
}
return l;
}
char **strv_path_canonicalize(char **l) {
char **s;
unsigned k = 0;
bool enomem = false;
if (strv_isempty(l))
return l;
/* Goes through every item in the string list and canonicalize
* the path. This works in place and won't rollback any
* changes on failure. */
STRV_FOREACH(s, l) {
char *t, *u;
t = path_make_absolute_cwd(*s);
free(*s);
if (!t) {
enomem = true;
continue;
}
errno = 0;
u = canonicalize_file_name(t);
free(t);
if (!u) {
if (errno == ENOMEM || !errno)
enomem = true;
continue;
}
l[k++] = u;
}
l[k] = NULL;
if (enomem)
return NULL;
return l;
}
int reset_all_signal_handlers(void) {
int sig;
for (sig = 1; sig < _NSIG; sig++) {
struct sigaction sa;
if (sig == SIGKILL || sig == SIGSTOP)
continue;
zero(sa);
sa.sa_handler = SIG_DFL;
sa.sa_flags = SA_RESTART;
/* On Linux the first two RT signals are reserved by
* glibc, and sigaction() will return EINVAL for them. */
if ((sigaction(sig, &sa, NULL) < 0))
if (errno != EINVAL)
return -errno;
}
return 0;
}
char *strstrip(char *s) {
char *e, *l = NULL;
/* Drops trailing whitespace. Modifies the string in
* place. Returns pointer to first non-space character */
s += strspn(s, WHITESPACE);
for (e = s; *e; e++)
if (!strchr(WHITESPACE, *e))
l = e;
if (l)
*(l+1) = 0;
else
*s = 0;
return s;
}
char *delete_chars(char *s, const char *bad) {
char *f, *t;
/* Drops all whitespace, regardless where in the string */
for (f = s, t = s; *f; f++) {
if (strchr(bad, *f))
continue;
*(t++) = *f;
}
*t = 0;
return s;
}
char *file_in_same_dir(const char *path, const char *filename) {
char *e, *r;
size_t k;
assert(path);
assert(filename);
/* This removes the last component of path and appends
* filename, unless the latter is absolute anyway or the
* former isn't */
if (path_is_absolute(filename))
return strdup(filename);
if (!(e = strrchr(path, '/')))
return strdup(filename);
k = strlen(filename);
if (!(r = new(char, e-path+1+k+1)))
return NULL;
memcpy(r, path, e-path+1);
memcpy(r+(e-path)+1, filename, k+1);
return r;
}
int safe_mkdir(const char *path, mode_t mode, uid_t uid, gid_t gid) {
struct stat st;
if (label_mkdir(path, mode) >= 0)
if (chmod_and_chown(path, mode, uid, gid) < 0)
return -errno;
if (lstat(path, &st) < 0)
return -errno;
if ((st.st_mode & 0777) != mode ||
st.st_uid != uid ||
st.st_gid != gid ||
!S_ISDIR(st.st_mode)) {
errno = EEXIST;
return -errno;
}
return 0;
}
int mkdir_parents(const char *path, mode_t mode) {
const char *p, *e;
assert(path);
/* Creates every parent directory in the path except the last
* component. */
p = path + strspn(path, "/");
for (;;) {
int r;
char *t;
e = p + strcspn(p, "/");
p = e + strspn(e, "/");
/* Is this the last component? If so, then we're
* done */
if (*p == 0)
return 0;
if (!(t = strndup(path, e - path)))
return -ENOMEM;
r = label_mkdir(t, mode);
free(t);
if (r < 0 && errno != EEXIST)
return -errno;
}
}
int mkdir_p(const char *path, mode_t mode) {
int r;
/* Like mkdir -p */
if ((r = mkdir_parents(path, mode)) < 0)
return r;
if (label_mkdir(path, mode) < 0 && errno != EEXIST)
return -errno;
return 0;
}
int rmdir_parents(const char *path, const char *stop) {
size_t l;
int r = 0;
assert(path);
assert(stop);
l = strlen(path);
/* Skip trailing slashes */
while (l > 0 && path[l-1] == '/')
l--;
while (l > 0) {
char *t;
/* Skip last component */
while (l > 0 && path[l-1] != '/')
l--;
/* Skip trailing slashes */
while (l > 0 && path[l-1] == '/')
l--;
if (l <= 0)
break;
if (!(t = strndup(path, l)))
return -ENOMEM;
if (path_startswith(stop, t)) {
free(t);
return 0;
}
r = rmdir(t);
free(t);
if (r < 0)
if (errno != ENOENT)
return -errno;
}
return 0;
}
char hexchar(int x) {
static const char table[16] = "0123456789abcdef";
return table[x & 15];
}
int unhexchar(char c) {
if (c >= '0' && c <= '9')
return c - '0';
if (c >= 'a' && c <= 'f')
return c - 'a' + 10;
if (c >= 'A' && c <= 'F')
return c - 'A' + 10;
return -1;
}
char octchar(int x) {
return '0' + (x & 7);
}
int unoctchar(char c) {
if (c >= '0' && c <= '7')
return c - '0';
return -1;
}
char decchar(int x) {
return '0' + (x % 10);
}
int undecchar(char c) {
if (c >= '0' && c <= '9')
return c - '0';
return -1;
}
char *cescape(const char *s) {
char *r, *t;
const char *f;
assert(s);
/* Does C style string escaping. */
if (!(r = new(char, strlen(s)*4 + 1)))
return NULL;
for (f = s, t = r; *f; f++)
switch (*f) {
case '\a':
*(t++) = '\\';
*(t++) = 'a';
break;
case '\b':
*(t++) = '\\';
*(t++) = 'b';
break;
case '\f':
*(t++) = '\\';
*(t++) = 'f';
break;
case '\n':
*(t++) = '\\';
*(t++) = 'n';
break;
case '\r':
*(t++) = '\\';
*(t++) = 'r';
break;
case '\t':
*(t++) = '\\';
*(t++) = 't';
break;
case '\v':
*(t++) = '\\';
*(t++) = 'v';
break;
case '\\':
*(t++) = '\\';
*(t++) = '\\';
break;
case '"':
*(t++) = '\\';
*(t++) = '"';
break;
case '\'':
*(t++) = '\\';
*(t++) = '\'';
break;
default:
/* For special chars we prefer octal over
* hexadecimal encoding, simply because glib's
* g_strescape() does the same */
if ((*f < ' ') || (*f >= 127)) {
*(t++) = '\\';
*(t++) = octchar((unsigned char) *f >> 6);
*(t++) = octchar((unsigned char) *f >> 3);
*(t++) = octchar((unsigned char) *f);
} else
*(t++) = *f;
break;
}
*t = 0;
return r;
}
char *cunescape_length(const char *s, size_t length) {
char *r, *t;
const char *f;
assert(s);
/* Undoes C style string escaping */
if (!(r = new(char, length+1)))
return r;
for (f = s, t = r; f < s + length; f++) {
if (*f != '\\') {
*(t++) = *f;
continue;
}
f++;
switch (*f) {
case 'a':
*(t++) = '\a';
break;
case 'b':
*(t++) = '\b';
break;
case 'f':
*(t++) = '\f';
break;
case 'n':
*(t++) = '\n';
break;
case 'r':
*(t++) = '\r';
break;
case 't':
*(t++) = '\t';
break;
case 'v':
*(t++) = '\v';
break;
case '\\':
*(t++) = '\\';
break;
case '"':
*(t++) = '"';
break;
case '\'':
*(t++) = '\'';
break;
case 's':
/* This is an extension of the XDG syntax files */
*(t++) = ' ';
break;
case 'x': {
/* hexadecimal encoding */
int a, b;
if ((a = unhexchar(f[1])) < 0 ||
(b = unhexchar(f[2])) < 0) {
/* Invalid escape code, let's take it literal then */
*(t++) = '\\';
*(t++) = 'x';
} else {
*(t++) = (char) ((a << 4) | b);
f += 2;
}
break;
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7': {
/* octal encoding */
int a, b, c;
if ((a = unoctchar(f[0])) < 0 ||
(b = unoctchar(f[1])) < 0 ||
(c = unoctchar(f[2])) < 0) {
/* Invalid escape code, let's take it literal then */
*(t++) = '\\';
*(t++) = f[0];
} else {
*(t++) = (char) ((a << 6) | (b << 3) | c);
f += 2;
}
break;
}
case 0:
/* premature end of string.*/
*(t++) = '\\';
goto finish;
default:
/* Invalid escape code, let's take it literal then */
*(t++) = '\\';
*(t++) = *f;
break;
}
}
finish:
*t = 0;
return r;
}
char *cunescape(const char *s) {
return cunescape_length(s, strlen(s));
}
char *xescape(const char *s, const char *bad) {
char *r, *t;
const char *f;
/* Escapes all chars in bad, in addition to \ and all special
* chars, in \xFF style escaping. May be reversed with
* cunescape. */
if (!(r = new(char, strlen(s)*4+1)))
return NULL;
for (f = s, t = r; *f; f++) {
if ((*f < ' ') || (*f >= 127) ||
(*f == '\\') || strchr(bad, *f)) {
*(t++) = '\\';
*(t++) = 'x';
*(t++) = hexchar(*f >> 4);
*(t++) = hexchar(*f);
} else
*(t++) = *f;
}
*t = 0;
return r;
}
char *bus_path_escape(const char *s) {
char *r, *t;
const char *f;
assert(s);
/* Escapes all chars that D-Bus' object path cannot deal
* with. Can be reverse with bus_path_unescape() */
if (!(r = new(char, strlen(s)*3+1)))
return NULL;
for (f = s, t = r; *f; f++) {
if (!(*f >= 'A' && *f <= 'Z') &&
!(*f >= 'a' && *f <= 'z') &&
!(*f >= '0' && *f <= '9')) {
*(t++) = '_';
*(t++) = hexchar(*f >> 4);
*(t++) = hexchar(*f);
} else
*(t++) = *f;
}
*t = 0;
return r;
}
char *bus_path_unescape(const char *f) {
char *r, *t;
assert(f);
if (!(r = strdup(f)))
return NULL;
for (t = r; *f; f++) {
if (*f == '_') {
int a, b;
if ((a = unhexchar(f[1])) < 0 ||
(b = unhexchar(f[2])) < 0) {
/* Invalid escape code, let's take it literal then */
*(t++) = '_';
} else {
*(t++) = (char) ((a << 4) | b);
f += 2;
}
} else
*(t++) = *f;
}
*t = 0;
return r;
}
char *path_kill_slashes(char *path) {
char *f, *t;
bool slash = false;
/* Removes redundant inner and trailing slashes. Modifies the
* passed string in-place.
*
* ///foo///bar/ becomes /foo/bar
*/
for (f = path, t = path; *f; f++) {
if (*f == '/') {
slash = true;
continue;
}
if (slash) {
slash = false;
*(t++) = '/';
}
*(t++) = *f;
}
/* Special rule, if we are talking of the root directory, a
trailing slash is good */
if (t == path && slash)
*(t++) = '/';
*t = 0;
return path;
}
bool path_startswith(const char *path, const char *prefix) {
assert(path);
assert(prefix);
if ((path[0] == '/') != (prefix[0] == '/'))
return false;
for (;;) {
size_t a, b;
path += strspn(path, "/");
prefix += strspn(prefix, "/");
if (*prefix == 0)
return true;
if (*path == 0)
return false;
a = strcspn(path, "/");
b = strcspn(prefix, "/");
if (a != b)
return false;
if (memcmp(path, prefix, a) != 0)
return false;
path += a;
prefix += b;
}
}
bool path_equal(const char *a, const char *b) {
assert(a);
assert(b);
if ((a[0] == '/') != (b[0] == '/'))
return false;
for (;;) {
size_t j, k;
a += strspn(a, "/");
b += strspn(b, "/");
if (*a == 0 && *b == 0)
return true;
if (*a == 0 || *b == 0)
return false;
j = strcspn(a, "/");
k = strcspn(b, "/");
if (j != k)
return false;
if (memcmp(a, b, j) != 0)
return false;
a += j;
b += k;
}
}
char *ascii_strlower(char *t) {
char *p;
assert(t);
for (p = t; *p; p++)
if (*p >= 'A' && *p <= 'Z')
*p = *p - 'A' + 'a';
return t;
}
bool ignore_file(const char *filename) {
assert(filename);
return
filename[0] == '.' ||
streq(filename, "lost+found") ||
endswith(filename, "~") ||
endswith(filename, ".rpmnew") ||
endswith(filename, ".rpmsave") ||
endswith(filename, ".rpmorig") ||
endswith(filename, ".dpkg-old") ||
endswith(filename, ".dpkg-new") ||
endswith(filename, ".swp");
}
int fd_nonblock(int fd, bool nonblock) {
int flags;
assert(fd >= 0);
if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
return -errno;
if (nonblock)
flags |= O_NONBLOCK;
else
flags &= ~O_NONBLOCK;
if (fcntl(fd, F_SETFL, flags) < 0)
return -errno;
return 0;
}
int fd_cloexec(int fd, bool cloexec) {
int flags;
assert(fd >= 0);
if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
return -errno;
if (cloexec)
flags |= FD_CLOEXEC;
else
flags &= ~FD_CLOEXEC;
if (fcntl(fd, F_SETFD, flags) < 0)
return -errno;
return 0;
}
int close_all_fds(const int except[], unsigned n_except) {
DIR *d;
struct dirent *de;
int r = 0;
if (!(d = opendir("/proc/self/fd")))
return -errno;
while ((de = readdir(d))) {
int fd = -1;
if (ignore_file(de->d_name))
continue;
if ((r = safe_atoi(de->d_name, &fd)) < 0)
goto finish;
if (fd < 3)
continue;
if (fd == dirfd(d))
continue;
if (except) {
bool found;
unsigned i;
found = false;
for (i = 0; i < n_except; i++)
if (except[i] == fd) {
found = true;
break;
}
if (found)
continue;
}
if ((r = close_nointr(fd)) < 0) {
/* Valgrind has its own FD and doesn't want to have it closed */
if (errno != EBADF)
goto finish;
}
}
r = 0;
finish:
closedir(d);
return r;
}
bool chars_intersect(const char *a, const char *b) {
const char *p;
/* Returns true if any of the chars in a are in b. */
for (p = a; *p; p++)
if (strchr(b, *p))
return true;
return false;
}
char *format_timestamp(char *buf, size_t l, usec_t t) {
struct tm tm;
time_t sec;
assert(buf);
assert(l > 0);
if (t <= 0)
return NULL;
sec = (time_t) (t / USEC_PER_SEC);
if (strftime(buf, l, "%a, %d %b %Y %H:%M:%S %z", localtime_r(&sec, &tm)) <= 0)
return NULL;
return buf;
}
char *format_timestamp_pretty(char *buf, size_t l, usec_t t) {
usec_t n, d;
n = now(CLOCK_REALTIME);
if (t <= 0 || t > n || t + USEC_PER_DAY*7 <= t)
return NULL;
d = n - t;
if (d >= USEC_PER_YEAR)
snprintf(buf, l, "%llu years and %llu months ago",
(unsigned long long) (d / USEC_PER_YEAR),
(unsigned long long) ((d % USEC_PER_YEAR) / USEC_PER_MONTH));
else if (d >= USEC_PER_MONTH)
snprintf(buf, l, "%llu months and %llu days ago",
(unsigned long long) (d / USEC_PER_MONTH),
(unsigned long long) ((d % USEC_PER_MONTH) / USEC_PER_DAY));
else if (d >= USEC_PER_WEEK)
snprintf(buf, l, "%llu weeks and %llu days ago",
(unsigned long long) (d / USEC_PER_WEEK),
(unsigned long long) ((d % USEC_PER_WEEK) / USEC_PER_DAY));
else if (d >= 2*USEC_PER_DAY)
snprintf(buf, l, "%llu days ago", (unsigned long long) (d / USEC_PER_DAY));
else if (d >= 25*USEC_PER_HOUR)
snprintf(buf, l, "1 day and %lluh ago",
(unsigned long long) ((d - USEC_PER_DAY) / USEC_PER_HOUR));
else if (d >= 6*USEC_PER_HOUR)
snprintf(buf, l, "%lluh ago",
(unsigned long long) (d / USEC_PER_HOUR));
else if (d >= USEC_PER_HOUR)
snprintf(buf, l, "%lluh %llumin ago",
(unsigned long long) (d / USEC_PER_HOUR),
(unsigned long long) ((d % USEC_PER_HOUR) / USEC_PER_MINUTE));
else if (d >= 5*USEC_PER_MINUTE)
snprintf(buf, l, "%llumin ago",
(unsigned long long) (d / USEC_PER_MINUTE));
else if (d >= USEC_PER_MINUTE)
snprintf(buf, l, "%llumin %llus ago",
(unsigned long long) (d / USEC_PER_MINUTE),
(unsigned long long) ((d % USEC_PER_MINUTE) / USEC_PER_SEC));
else if (d >= USEC_PER_SEC)
snprintf(buf, l, "%llus ago",
(unsigned long long) (d / USEC_PER_SEC));
else if (d >= USEC_PER_MSEC)
snprintf(buf, l, "%llums ago",
(unsigned long long) (d / USEC_PER_MSEC));
else if (d > 0)
snprintf(buf, l, "%lluus ago",
(unsigned long long) d);
else
snprintf(buf, l, "now");
buf[l-1] = 0;
return buf;
}
char *format_timespan(char *buf, size_t l, usec_t t) {
static const struct {
const char *suffix;
usec_t usec;
} table[] = {
{ "w", USEC_PER_WEEK },
{ "d", USEC_PER_DAY },
{ "h", USEC_PER_HOUR },
{ "min", USEC_PER_MINUTE },
{ "s", USEC_PER_SEC },
{ "ms", USEC_PER_MSEC },
{ "us", 1 },
};
unsigned i;
char *p = buf;
assert(buf);
assert(l > 0);
if (t == (usec_t) -1)
return NULL;
if (t == 0) {
snprintf(p, l, "0");
p[l-1] = 0;
return p;
}
/* The result of this function can be parsed with parse_usec */
for (i = 0; i < ELEMENTSOF(table); i++) {
int k;
size_t n;
if (t < table[i].usec)
continue;
if (l <= 1)
break;
k = snprintf(p, l, "%s%llu%s", p > buf ? " " : "", (unsigned long long) (t / table[i].usec), table[i].suffix);
n = MIN((size_t) k, l);
l -= n;
p += n;
t %= table[i].usec;
}
*p = 0;
return buf;
}
bool fstype_is_network(const char *fstype) {
static const char * const table[] = {
"cifs",
"smbfs",
"ncpfs",
"nfs",
"nfs4",
"gfs",
"gfs2"
};
unsigned i;
for (i = 0; i < ELEMENTSOF(table); i++)
if (streq(table[i], fstype))
return true;
return false;
}
int chvt(int vt) {
int fd, r = 0;
if ((fd = open("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC)) < 0)
return -errno;
if (vt < 0) {
int tiocl[2] = {
TIOCL_GETKMSGREDIRECT,
0
};
if (ioctl(fd, TIOCLINUX, tiocl) < 0)
return -errno;
vt = tiocl[0] <= 0 ? 1 : tiocl[0];
}
if (ioctl(fd, VT_ACTIVATE, vt) < 0)
r = -errno;
close_nointr_nofail(r);
return r;
}
int read_one_char(FILE *f, char *ret, bool *need_nl) {
struct termios old_termios, new_termios;
char c;
char line[1024];
assert(f);
assert(ret);
if (tcgetattr(fileno(f), &old_termios) >= 0) {
new_termios = old_termios;
new_termios.c_lflag &= ~ICANON;
new_termios.c_cc[VMIN] = 1;
new_termios.c_cc[VTIME] = 0;
if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
size_t k;
k = fread(&c, 1, 1, f);
tcsetattr(fileno(f), TCSADRAIN, &old_termios);
if (k <= 0)
return -EIO;
if (need_nl)
*need_nl = c != '\n';
*ret = c;
return 0;
}
}
if (!(fgets(line, sizeof(line), f)))
return -EIO;
truncate_nl(line);
if (strlen(line) != 1)
return -EBADMSG;
if (need_nl)
*need_nl = false;
*ret = line[0];
return 0;
}
int ask(char *ret, const char *replies, const char *text, ...) {
bool on_tty;
assert(ret);
assert(replies);
assert(text);
on_tty = isatty(STDOUT_FILENO);
for (;;) {
va_list ap;
char c;
int r;
bool need_nl = true;
if (on_tty)
fputs("\x1B[1m", stdout);
va_start(ap, text);
vprintf(text, ap);
va_end(ap);
if (on_tty)
fputs("\x1B[0m", stdout);
fflush(stdout);
if ((r = read_one_char(stdin, &c, &need_nl)) < 0) {
if (r == -EBADMSG) {
puts("Bad input, please try again.");
continue;
}
putchar('\n');
return r;
}
if (need_nl)
putchar('\n');
if (strchr(replies, c)) {
*ret = c;
return 0;
}
puts("Read unexpected character, please try again.");
}
}
int reset_terminal(int fd) {
struct termios termios;
int r = 0;
long arg;
/* Set terminal to some sane defaults */
assert(fd >= 0);
/* We leave locked terminal attributes untouched, so that
* Plymouth may set whatever it wants to set, and we don't
* interfere with that. */
/* Disable exclusive mode, just in case */
ioctl(fd, TIOCNXCL);
/* Enable console unicode mode */
arg = K_UNICODE;
ioctl(fd, KDSKBMODE, &arg);
if (tcgetattr(fd, &termios) < 0) {
r = -errno;
goto finish;
}
/* We only reset the stuff that matters to the software. How
* hardware is set up we don't touch assuming that somebody
* else will do that for us */
termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
termios.c_oflag |= ONLCR;
termios.c_cflag |= CREAD;
termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
termios.c_cc[VINTR] = 03; /* ^C */
termios.c_cc[VQUIT] = 034; /* ^\ */
termios.c_cc[VERASE] = 0177;
termios.c_cc[VKILL] = 025; /* ^X */
termios.c_cc[VEOF] = 04; /* ^D */
termios.c_cc[VSTART] = 021; /* ^Q */
termios.c_cc[VSTOP] = 023; /* ^S */
termios.c_cc[VSUSP] = 032; /* ^Z */
termios.c_cc[VLNEXT] = 026; /* ^V */
termios.c_cc[VWERASE] = 027; /* ^W */
termios.c_cc[VREPRINT] = 022; /* ^R */
termios.c_cc[VEOL] = 0;
termios.c_cc[VEOL2] = 0;
termios.c_cc[VTIME] = 0;
termios.c_cc[VMIN] = 1;
if (tcsetattr(fd, TCSANOW, &termios) < 0)
r = -errno;
finish:
/* Just in case, flush all crap out */
tcflush(fd, TCIOFLUSH);
return r;
}
int open_terminal(const char *name, int mode) {
int fd, r;
if ((fd = open(name, mode)) < 0)
return -errno;
if ((r = isatty(fd)) < 0) {
close_nointr_nofail(fd);
return -errno;
}
if (!r) {
close_nointr_nofail(fd);
return -ENOTTY;
}
return fd;
}
int flush_fd(int fd) {
struct pollfd pollfd;
zero(pollfd);
pollfd.fd = fd;
pollfd.events = POLLIN;
for (;;) {
char buf[1024];
ssize_t l;
int r;
if ((r = poll(&pollfd, 1, 0)) < 0) {
if (errno == EINTR)
continue;
return -errno;
}
if (r == 0)
return 0;
if ((l = read(fd, buf, sizeof(buf))) < 0) {
if (errno == EINTR)
continue;
if (errno == EAGAIN)
return 0;
return -errno;
}
if (l <= 0)
return 0;
}
}
int acquire_terminal(const char *name, bool fail, bool force, bool ignore_tiocstty_eperm) {
int fd = -1, notify = -1, r, wd = -1;
assert(name);
/* We use inotify to be notified when the tty is closed. We
* create the watch before checking if we can actually acquire
* it, so that we don't lose any event.
*
* Note: strictly speaking this actually watches for the
* device being closed, it does *not* really watch whether a
* tty loses its controlling process. However, unless some
* rogue process uses TIOCNOTTY on /dev/tty *after* closing
* its tty otherwise this will not become a problem. As long
* as the administrator makes sure not configure any service
* on the same tty as an untrusted user this should not be a
* problem. (Which he probably should not do anyway.) */
if (!fail && !force) {
if ((notify = inotify_init1(IN_CLOEXEC)) < 0) {
r = -errno;
goto fail;
}
if ((wd = inotify_add_watch(notify, name, IN_CLOSE)) < 0) {
r = -errno;
goto fail;
}
}
for (;;) {
if (notify >= 0)
if ((r = flush_fd(notify)) < 0)
goto fail;
/* We pass here O_NOCTTY only so that we can check the return
* value TIOCSCTTY and have a reliable way to figure out if we
* successfully became the controlling process of the tty */
if ((fd = open_terminal(name, O_RDWR|O_NOCTTY)) < 0)
return -errno;
/* First, try to get the tty */
r = ioctl(fd, TIOCSCTTY, force);
/* Sometimes it makes sense to ignore TIOCSCTTY
* returning EPERM, i.e. when very likely we already
* are have this controlling terminal. */
if (r < 0 && errno == EPERM && ignore_tiocstty_eperm)
r = 0;
if (r < 0 && (force || fail || errno != EPERM)) {
r = -errno;
goto fail;
}
if (r >= 0)
break;
assert(!fail);
assert(!force);
assert(notify >= 0);
for (;;) {
uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
ssize_t l;
struct inotify_event *e;
if ((l = read(notify, &inotify_buffer, sizeof(inotify_buffer))) < 0) {
if (errno == EINTR)
continue;
r = -errno;
goto fail;
}
e = (struct inotify_event*) inotify_buffer;
while (l > 0) {
size_t step;
if (e->wd != wd || !(e->mask & IN_CLOSE)) {
r = -EIO;
goto fail;
}
step = sizeof(struct inotify_event) + e->len;
assert(step <= (size_t) l);
e = (struct inotify_event*) ((uint8_t*) e + step);
l -= step;
}
break;
}
/* We close the tty fd here since if the old session
* ended our handle will be dead. It's important that
* we do this after sleeping, so that we don't enter
* an endless loop. */
close_nointr_nofail(fd);
}
if (notify >= 0)
close_nointr_nofail(notify);
if ((r = reset_terminal(fd)) < 0)
log_warning("Failed to reset terminal: %s", strerror(-r));
return fd;
fail:
if (fd >= 0)
close_nointr_nofail(fd);
if (notify >= 0)
close_nointr_nofail(notify);
return r;
}
int release_terminal(void) {
int r = 0, fd;
struct sigaction sa_old, sa_new;
if ((fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY)) < 0)
return -errno;
/* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
* by our own TIOCNOTTY */
zero(sa_new);
sa_new.sa_handler = SIG_IGN;
sa_new.sa_flags = SA_RESTART;
assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
if (ioctl(fd, TIOCNOTTY) < 0)
r = -errno;
assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
close_nointr_nofail(fd);
return r;
}
int sigaction_many(const struct sigaction *sa, ...) {
va_list ap;
int r = 0, sig;
va_start(ap, sa);
while ((sig = va_arg(ap, int)) > 0)
if (sigaction(sig, sa, NULL) < 0)
r = -errno;
va_end(ap);
return r;
}
int ignore_signals(int sig, ...) {
struct sigaction sa;
va_list ap;
int r = 0;
zero(sa);
sa.sa_handler = SIG_IGN;
sa.sa_flags = SA_RESTART;
if (sigaction(sig, &sa, NULL) < 0)
r = -errno;
va_start(ap, sig);
while ((sig = va_arg(ap, int)) > 0)
if (sigaction(sig, &sa, NULL) < 0)
r = -errno;
va_end(ap);
return r;
}
int default_signals(int sig, ...) {
struct sigaction sa;
va_list ap;
int r = 0;
zero(sa);
sa.sa_handler = SIG_DFL;
sa.sa_flags = SA_RESTART;
if (sigaction(sig, &sa, NULL) < 0)
r = -errno;
va_start(ap, sig);
while ((sig = va_arg(ap, int)) > 0)
if (sigaction(sig, &sa, NULL) < 0)
r = -errno;
va_end(ap);
return r;
}
int close_pipe(int p[]) {
int a = 0, b = 0;
assert(p);
if (p[0] >= 0) {
a = close_nointr(p[0]);
p[0] = -1;
}
if (p[1] >= 0) {
b = close_nointr(p[1]);
p[1] = -1;
}
return a < 0 ? a : b;
}
ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
uint8_t *p;
ssize_t n = 0;
assert(fd >= 0);
assert(buf);
p = buf;
while (nbytes > 0) {
ssize_t k;
if ((k = read(fd, p, nbytes)) <= 0) {
if (k < 0 && errno == EINTR)
continue;
if (k < 0 && errno == EAGAIN && do_poll) {
struct pollfd pollfd;
zero(pollfd);
pollfd.fd = fd;
pollfd.events = POLLIN;
if (poll(&pollfd, 1, -1) < 0) {
if (errno == EINTR)
continue;
return n > 0 ? n : -errno;
}
if (pollfd.revents != POLLIN)
return n > 0 ? n : -EIO;
continue;
}
return n > 0 ? n : (k < 0 ? -errno : 0);
}
p += k;
nbytes -= k;
n += k;
}
return n;
}
ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
const uint8_t *p;
ssize_t n = 0;
assert(fd >= 0);
assert(buf);
p = buf;
while (nbytes > 0) {
ssize_t k;
if ((k = write(fd, p, nbytes)) <= 0) {
if (k < 0 && errno == EINTR)
continue;
if (k < 0 && errno == EAGAIN && do_poll) {
struct pollfd pollfd;
zero(pollfd);
pollfd.fd = fd;
pollfd.events = POLLOUT;
if (poll(&pollfd, 1, -1) < 0) {
if (errno == EINTR)
continue;
return n > 0 ? n : -errno;
}
if (pollfd.revents != POLLOUT)
return n > 0 ? n : -EIO;
continue;
}
return n > 0 ? n : (k < 0 ? -errno : 0);
}
p += k;
nbytes -= k;
n += k;
}
return n;
}
int path_is_mount_point(const char *t) {
struct stat a, b;
char *parent;
int r;
if (lstat(t, &a) < 0) {
if (errno == ENOENT)
return 0;
return -errno;
}
if ((r = parent_of_path(t, &parent)) < 0)
return r;
r = lstat(parent, &b);
free(parent);
if (r < 0)
return -errno;
return a.st_dev != b.st_dev;
}
int parse_usec(const char *t, usec_t *usec) {
static const struct {
const char *suffix;
usec_t usec;
} table[] = {
{ "sec", USEC_PER_SEC },
{ "s", USEC_PER_SEC },
{ "min", USEC_PER_MINUTE },
{ "hr", USEC_PER_HOUR },
{ "h", USEC_PER_HOUR },
{ "d", USEC_PER_DAY },
{ "w", USEC_PER_WEEK },
{ "msec", USEC_PER_MSEC },
{ "ms", USEC_PER_MSEC },
{ "m", USEC_PER_MINUTE },
{ "usec", 1ULL },
{ "us", 1ULL },
{ "", USEC_PER_SEC },
};
const char *p;
usec_t r = 0;
assert(t);
assert(usec);
p = t;
do {
long long l;
char *e;
unsigned i;
errno = 0;
l = strtoll(p, &e, 10);
if (errno != 0)
return -errno;
if (l < 0)
return -ERANGE;
if (e == p)
return -EINVAL;
e += strspn(e, WHITESPACE);
for (i = 0; i < ELEMENTSOF(table); i++)
if (startswith(e, table[i].suffix)) {
r += (usec_t) l * table[i].usec;
p = e + strlen(table[i].suffix);
break;
}
if (i >= ELEMENTSOF(table))
return -EINVAL;
} while (*p != 0);
*usec = r;
return 0;
}
int make_stdio(int fd) {
int r, s, t;
assert(fd >= 0);
r = dup2(fd, STDIN_FILENO);
s = dup2(fd, STDOUT_FILENO);
t = dup2(fd, STDERR_FILENO);
if (fd >= 3)
close_nointr_nofail(fd);
if (r < 0 || s < 0 || t < 0)
return -errno;
return 0;
}
bool is_clean_exit(int code, int status) {
if (code == CLD_EXITED)
return status == 0;
/* If a daemon does not implement handlers for some of the
* signals that's not considered an unclean shutdown */
if (code == CLD_KILLED)
return
status == SIGHUP ||
status == SIGINT ||
status == SIGTERM ||
status == SIGPIPE;
return false;
}
bool is_clean_exit_lsb(int code, int status) {
if (is_clean_exit(code, status))
return true;
return
code == CLD_EXITED &&
(status == EXIT_NOTINSTALLED || status == EXIT_NOTCONFIGURED);
}
bool is_device_path(const char *path) {
/* Returns true on paths that refer to a device, either in
* sysfs or in /dev */
return
path_startswith(path, "/dev/") ||
path_startswith(path, "/sys/");
}
int dir_is_empty(const char *path) {
DIR *d;
int r;
struct dirent buf, *de;
if (!(d = opendir(path)))
return -errno;
for (;;) {
if ((r = readdir_r(d, &buf, &de)) > 0) {
r = -r;
break;
}
if (!de) {
r = 1;
break;
}
if (!ignore_file(de->d_name)) {
r = 0;
break;
}
}
closedir(d);
return r;
}
unsigned long long random_ull(void) {
int fd;
uint64_t ull;
ssize_t r;
if ((fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY)) < 0)
goto fallback;
r = loop_read(fd, &ull, sizeof(ull), true);
close_nointr_nofail(fd);
if (r != sizeof(ull))
goto fallback;
return ull;
fallback:
return random() * RAND_MAX + random();
}
void rename_process(const char name[8]) {
assert(name);
prctl(PR_SET_NAME, name);
/* This is a like a poor man's setproctitle(). The string
* passed should fit in 7 chars (i.e. the length of
* "systemd") */
if (program_invocation_name)
strncpy(program_invocation_name, name, strlen(program_invocation_name));
}
void sigset_add_many(sigset_t *ss, ...) {
va_list ap;
int sig;
assert(ss);
va_start(ap, ss);
while ((sig = va_arg(ap, int)) > 0)
assert_se(sigaddset(ss, sig) == 0);
va_end(ap);
}
char* gethostname_malloc(void) {
struct utsname u;
assert_se(uname(&u) >= 0);
if (u.nodename[0])
return strdup(u.nodename);
return strdup(u.sysname);
}
char* getlogname_malloc(void) {
uid_t uid;
long bufsize;
char *buf, *name;
struct passwd pwbuf, *pw = NULL;
struct stat st;
if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
uid = st.st_uid;
else
uid = getuid();
/* Shortcut things to avoid NSS lookups */
if (uid == 0)
return strdup("root");
if ((bufsize = sysconf(_SC_GETPW_R_SIZE_MAX)) <= 0)
bufsize = 4096;
if (!(buf = malloc(bufsize)))
return NULL;
if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw) {
name = strdup(pw->pw_name);
free(buf);
return name;
}
free(buf);
if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
return NULL;
return name;
}
int getttyname_malloc(char **r) {
char path[PATH_MAX], *p, *c;
int k;
assert(r);
if ((k = ttyname_r(STDIN_FILENO, path, sizeof(path))) != 0)
return -k;
char_array_0(path);
p = path;
if (startswith(path, "/dev/"))
p += 5;
if (!(c = strdup(p)))
return -ENOMEM;
*r = c;
return 0;
}
static int rm_rf_children(int fd, bool only_dirs) {
DIR *d;
int ret = 0;
assert(fd >= 0);
/* This returns the first error we run into, but nevertheless
* tries to go on */
if (!(d = fdopendir(fd))) {
close_nointr_nofail(fd);
return errno == ENOENT ? 0 : -errno;
}
for (;;) {
struct dirent buf, *de;
bool is_dir;
int r;
if ((r = readdir_r(d, &buf, &de)) != 0) {
if (ret == 0)
ret = -r;
break;
}
if (!de)
break;
if (streq(de->d_name, ".") || streq(de->d_name, ".."))
continue;
if (de->d_type == DT_UNKNOWN) {
struct stat st;
if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
if (ret == 0 && errno != ENOENT)
ret = -errno;
continue;
}
is_dir = S_ISDIR(st.st_mode);
} else
is_dir = de->d_type == DT_DIR;
if (is_dir) {
int subdir_fd;
if ((subdir_fd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC)) < 0) {
if (ret == 0 && errno != ENOENT)
ret = -errno;
continue;
}
if ((r = rm_rf_children(subdir_fd, only_dirs)) < 0) {
if (ret == 0)
ret = r;
}
if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
if (ret == 0 && errno != ENOENT)
ret = -errno;
}
} else if (!only_dirs) {
if (unlinkat(fd, de->d_name, 0) < 0) {
if (ret == 0 && errno != ENOENT)
ret = -errno;
}
}
}
closedir(d);
return ret;
}
int rm_rf(const char *path, bool only_dirs, bool delete_root) {
int fd;
int r;
assert(path);
if ((fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC)) < 0) {
if (errno != ENOTDIR)
return -errno;
if (delete_root && !only_dirs)
if (unlink(path) < 0)
return -errno;
return 0;
}
r = rm_rf_children(fd, only_dirs);
if (delete_root)
if (rmdir(path) < 0) {
if (r == 0)
r = -errno;
}
return r;
}
int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
assert(path);
/* Under the assumption that we are running privileged we
* first change the access mode and only then hand out
* ownership to avoid a window where access is too open. */
if (chmod(path, mode) < 0)
return -errno;
if (chown(path, uid, gid) < 0)
return -errno;
return 0;
}
cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
cpu_set_t *r;
unsigned n = 1024;
/* Allocates the cpuset in the right size */
for (;;) {
if (!(r = CPU_ALLOC(n)))
return NULL;
if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
if (ncpus)
*ncpus = n;
return r;
}
CPU_FREE(r);
if (errno != EINVAL)
return NULL;
n *= 2;
}
}
void status_vprintf(const char *format, va_list ap) {
char *s = NULL;
int fd = -1;
assert(format);
/* This independent of logging, as status messages are
* optional and go exclusively to the console. */
if (vasprintf(&s, format, ap) < 0)
goto finish;
if ((fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC)) < 0)
goto finish;
write(fd, s, strlen(s));
finish:
free(s);
if (fd >= 0)
close_nointr_nofail(fd);
}
void status_printf(const char *format, ...) {
va_list ap;
assert(format);
va_start(ap, format);
status_vprintf(format, ap);
va_end(ap);
}
void status_welcome(void) {
#if defined(TARGET_FEDORA)
char *r;
if (read_one_line_file("/etc/system-release", &r) < 0)
return;
truncate_nl(r);
/* This tries to mimic the color magic the old Red Hat sysinit
* script did. */
if (startswith(r, "Red Hat"))
status_printf("Welcome to \x1B[0;31m%s\x1B[0m!\n", r); /* Red for RHEL */
else if (startswith(r, "Fedora"))
status_printf("Welcome to \x1B[0;34m%s\x1B[0m!\n", r); /* Blue for Fedora */
else
status_printf("Welcome to %s!\n", r);
free(r);
#elif defined(TARGET_SUSE)
char *r;
if (read_one_line_file("/etc/SuSE-release", &r) < 0)
return;
truncate_nl(r);
status_printf("Welcome to \x1B[0;32m%s\x1B[0m!\n", r); /* Green for SUSE */
free(r);
#elif defined(TARGET_GENTOO)
char *r;
if (read_one_line_file("/etc/gentoo-release", &r) < 0)
return;
truncate_nl(r);
status_printf("Welcome to \x1B[1;34m%s\x1B[0m!\n", r); /* Light Blue for Gentoo */
free(r);
#elif defined(TARGET_DEBIAN)
char *r;
if (read_one_line_file("/etc/debian_version", &r) < 0)
return;
truncate_nl(r);
status_printf("Welcome to Debian \x1B[1;31m%s\x1B[0m!\n", r); /* Light Red for Debian */
free(r);
#elif defined(TARGET_ARCH)
status_printf("Welcome to \x1B[1;36mArch Linux\x1B[0m!\n"); /* Cyan for Arch */
#else
#warning "You probably should add a welcome text logic here."
#endif
}
char *replace_env(const char *format, char **env) {
enum {
WORD,
CURLY,
VARIABLE
} state = WORD;
const char *e, *word = format;
char *r = NULL, *k;
assert(format);
for (e = format; *e; e ++) {
switch (state) {
case WORD:
if (*e == '$')
state = CURLY;
break;
case CURLY:
if (*e == '{') {
if (!(k = strnappend(r, word, e-word-1)))
goto fail;
free(r);
r = k;
word = e-1;
state = VARIABLE;
} else if (*e == '$') {
if (!(k = strnappend(r, word, e-word)))
goto fail;
free(r);
r = k;
word = e+1;
state = WORD;
} else
state = WORD;
break;
case VARIABLE:
if (*e == '}') {
const char *t;
if (!(t = strv_env_get_with_length(env, word+2, e-word-2)))
t = "";
if (!(k = strappend(r, t)))
goto fail;
free(r);
r = k;
word = e+1;
state = WORD;
}
break;
}
}
if (!(k = strnappend(r, word, e-word)))
goto fail;
free(r);
return k;
fail:
free(r);
return NULL;
}
char **replace_env_argv(char **argv, char **env) {
char **r, **i;
unsigned k = 0, l = 0;
l = strv_length(argv);
if (!(r = new(char*, l+1)))
return NULL;
STRV_FOREACH(i, argv) {
/* If $FOO appears as single word, replace it by the split up variable */
if ((*i)[0] == '$' && (*i)[1] != '{') {
char *e;
char **w, **m;
unsigned q;
if ((e = strv_env_get(env, *i+1))) {
if (!(m = strv_split_quoted(e))) {
r[k] = NULL;
strv_free(r);
return NULL;
}
} else
m = NULL;
q = strv_length(m);
l = l + q - 1;
if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
r[k] = NULL;
strv_free(r);
strv_free(m);
return NULL;
}
r = w;
if (m) {
memcpy(r + k, m, q * sizeof(char*));
free(m);
}
k += q;
continue;
}
/* If ${FOO} appears as part of a word, replace it by the variable as-is */
if (!(r[k++] = replace_env(*i, env))) {
strv_free(r);
return NULL;
}
}
r[k] = NULL;
return r;
}
int columns(void) {
static __thread int parsed_columns = 0;
const char *e;
if (parsed_columns > 0)
return parsed_columns;
if ((e = getenv("COLUMNS")))
parsed_columns = atoi(e);
if (parsed_columns <= 0) {
struct winsize ws;
zero(ws);
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) >= 0)
parsed_columns = ws.ws_col;
}
if (parsed_columns <= 0)
parsed_columns = 80;
return parsed_columns;
}
int running_in_chroot(void) {
struct stat a, b;
zero(a);
zero(b);
/* Only works as root */
if (stat("/proc/1/root", &a) < 0)
return -errno;
if (stat("/", &b) < 0)
return -errno;
return
a.st_dev != b.st_dev ||
a.st_ino != b.st_ino;
}
char *ellipsize(const char *s, unsigned length, unsigned percent) {
size_t l, x;
char *r;
assert(s);
assert(percent <= 100);
assert(length >= 3);
l = strlen(s);
if (l <= 3 || l <= length)
return strdup(s);
if (!(r = new0(char, length+1)))
return r;
x = (length * percent) / 100;
if (x > length - 3)
x = length - 3;
memcpy(r, s, x);
r[x] = '.';
r[x+1] = '.';
r[x+2] = '.';
memcpy(r + x + 3,
s + l - (length - x - 3),
length - x - 3);
return r;
}
int touch(const char *path) {
int fd;
assert(path);
if ((fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0666)) < 0)
return -errno;
close_nointr_nofail(fd);
return 0;
}
char *unquote(const char *s, const char* quotes) {
size_t l;
assert(s);
if ((l = strlen(s)) < 2)
return strdup(s);
if (strchr(quotes, s[0]) && s[l-1] == s[0])
return strndup(s+1, l-2);
return strdup(s);
}
int wait_for_terminate(pid_t pid, siginfo_t *status) {
assert(pid >= 1);
assert(status);
for (;;) {
zero(*status);
if (waitid(P_PID, pid, status, WEXITED) < 0) {
if (errno == EINTR)
continue;
return -errno;
}
return 0;
}
}
int wait_for_terminate_and_warn(const char *name, pid_t pid) {
int r;
siginfo_t status;
assert(name);
assert(pid > 1);
if ((r = wait_for_terminate(pid, &status)) < 0) {
log_warning("Failed to wait for %s: %s", name, strerror(-r));
return r;
}
if (status.si_code == CLD_EXITED) {
if (status.si_status != 0) {
log_warning("%s failed with error code %i.", name, status.si_status);
return -EPROTO;
}
log_debug("%s succeeded.", name);
return 0;
} else if (status.si_code == CLD_KILLED ||
status.si_code == CLD_DUMPED) {
log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
return -EPROTO;
}
log_warning("%s failed due to unknown reason.", name);
return -EPROTO;
}
void freeze(void) {
for (;;)
pause();
}
bool null_or_empty(struct stat *st) {
assert(st);
if (S_ISREG(st->st_mode) && st->st_size <= 0)
return true;
if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
return true;
return false;
}
DIR *xopendirat(int fd, const char *name) {
return fdopendir(openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC));
}
static const char *const ioprio_class_table[] = {
[IOPRIO_CLASS_NONE] = "none",
[IOPRIO_CLASS_RT] = "realtime",
[IOPRIO_CLASS_BE] = "best-effort",
[IOPRIO_CLASS_IDLE] = "idle"
};
DEFINE_STRING_TABLE_LOOKUP(ioprio_class, int);
static const char *const sigchld_code_table[] = {
[CLD_EXITED] = "exited",
[CLD_KILLED] = "killed",
[CLD_DUMPED] = "dumped",
[CLD_TRAPPED] = "trapped",
[CLD_STOPPED] = "stopped",
[CLD_CONTINUED] = "continued",
};
DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
static const char *const log_facility_table[LOG_NFACILITIES] = {
[LOG_FAC(LOG_KERN)] = "kern",
[LOG_FAC(LOG_USER)] = "user",
[LOG_FAC(LOG_MAIL)] = "mail",
[LOG_FAC(LOG_DAEMON)] = "daemon",
[LOG_FAC(LOG_AUTH)] = "auth",
[LOG_FAC(LOG_SYSLOG)] = "syslog",
[LOG_FAC(LOG_LPR)] = "lpr",
[LOG_FAC(LOG_NEWS)] = "news",
[LOG_FAC(LOG_UUCP)] = "uucp",
[LOG_FAC(LOG_CRON)] = "cron",
[LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
[LOG_FAC(LOG_FTP)] = "ftp",
[LOG_FAC(LOG_LOCAL0)] = "local0",
[LOG_FAC(LOG_LOCAL1)] = "local1",
[LOG_FAC(LOG_LOCAL2)] = "local2",
[LOG_FAC(LOG_LOCAL3)] = "local3",
[LOG_FAC(LOG_LOCAL4)] = "local4",
[LOG_FAC(LOG_LOCAL5)] = "local5",
[LOG_FAC(LOG_LOCAL6)] = "local6",
[LOG_FAC(LOG_LOCAL7)] = "local7"
};
DEFINE_STRING_TABLE_LOOKUP(log_facility, int);
static const char *const log_level_table[] = {
[LOG_EMERG] = "emerg",
[LOG_ALERT] = "alert",
[LOG_CRIT] = "crit",
[LOG_ERR] = "err",
[LOG_WARNING] = "warning",
[LOG_NOTICE] = "notice",
[LOG_INFO] = "info",
[LOG_DEBUG] = "debug"
};
DEFINE_STRING_TABLE_LOOKUP(log_level, int);
static const char* const sched_policy_table[] = {
[SCHED_OTHER] = "other",
[SCHED_BATCH] = "batch",
[SCHED_IDLE] = "idle",
[SCHED_FIFO] = "fifo",
[SCHED_RR] = "rr"
};
DEFINE_STRING_TABLE_LOOKUP(sched_policy, int);
static const char* const rlimit_table[] = {
[RLIMIT_CPU] = "LimitCPU",
[RLIMIT_FSIZE] = "LimitFSIZE",
[RLIMIT_DATA] = "LimitDATA",
[RLIMIT_STACK] = "LimitSTACK",
[RLIMIT_CORE] = "LimitCORE",
[RLIMIT_RSS] = "LimitRSS",
[RLIMIT_NOFILE] = "LimitNOFILE",
[RLIMIT_AS] = "LimitAS",
[RLIMIT_NPROC] = "LimitNPROC",
[RLIMIT_MEMLOCK] = "LimitMEMLOCK",
[RLIMIT_LOCKS] = "LimitLOCKS",
[RLIMIT_SIGPENDING] = "LimitSIGPENDING",
[RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
[RLIMIT_NICE] = "LimitNICE",
[RLIMIT_RTPRIO] = "LimitRTPRIO",
[RLIMIT_RTTIME] = "LimitRTTIME"
};
DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
static const char* const ip_tos_table[] = {
[IPTOS_LOWDELAY] = "low-delay",
[IPTOS_THROUGHPUT] = "throughput",
[IPTOS_RELIABILITY] = "reliability",
[IPTOS_LOWCOST] = "low-cost",
};
DEFINE_STRING_TABLE_LOOKUP(ip_tos, int);
static const char *const signal_table[] = {
[SIGHUP] = "HUP",
[SIGINT] = "INT",
[SIGQUIT] = "QUIT",
[SIGILL] = "ILL",
[SIGTRAP] = "TRAP",
[SIGABRT] = "ABRT",
[SIGBUS] = "BUS",
[SIGFPE] = "FPE",
[SIGKILL] = "KILL",
[SIGUSR1] = "USR1",
[SIGSEGV] = "SEGV",
[SIGUSR2] = "USR2",
[SIGPIPE] = "PIPE",
[SIGALRM] = "ALRM",
[SIGTERM] = "TERM",
#ifdef SIGSTKFLT
[SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
#endif
[SIGCHLD] = "CHLD",
[SIGCONT] = "CONT",
[SIGSTOP] = "STOP",
[SIGTSTP] = "TSTP",
[SIGTTIN] = "TTIN",
[SIGTTOU] = "TTOU",
[SIGURG] = "URG",
[SIGXCPU] = "XCPU",
[SIGXFSZ] = "XFSZ",
[SIGVTALRM] = "VTALRM",
[SIGPROF] = "PROF",
[SIGWINCH] = "WINCH",
[SIGIO] = "IO",
[SIGPWR] = "PWR",
[SIGSYS] = "SYS"
};
DEFINE_STRING_TABLE_LOOKUP(signal, int);