util: when using basename() for creating temporary files, verify the resulting name...

[elogind.git] / src / shared / util.c

diff --git a/src/shared/util.c b/src/shared/util.c
index f8511ff4aae6d742dfbb4120e927b6bce38012e5..273552f62222ea579244ae1244e08b1a62d993f3 100644 (file)
--- a/src/shared/util.c
+++ b/src/shared/util.c
@@ -354,7 +354,7 @@ int parse_uid(const char *s, uid_t* ret_uid) {
         if ((unsigned long) uid != ul)
                 return -ERANGE;
 
         if ((unsigned long) uid != ul)
                 return -ERANGE;
 

-        /* Some libc APIs use (uid_t) -1 as special placeholder */
+        /* Some libc APIs use UID_INVALID as special placeholder */

         if (uid == (uid_t) 0xFFFFFFFF)
                 return -ENXIO;
 
         if (uid == (uid_t) 0xFFFFFFFF)
                 return -ENXIO;
 


@@ -558,7 +558,7 @@ const char* split(const char **state, size_t *l, const char *separator, bool quo
                 *l = strcspn_escaped(current + 1, quotechars);
                 if (current[*l + 1] == '\0' ||
                     (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
                 *l = strcspn_escaped(current + 1, quotechars);
                 if (current[*l + 1] == '\0' ||
                     (current[*l + 2] && !strchr(separator, current[*l + 2]))) {

-                        /* right quote missing or garbage at the end*/
+                        /* right quote missing or garbage at the end */

                         *state = current;
                         return NULL;
                 }
                         *state = current;
                         return NULL;
                 }


@@ -618,56 +618,6 @@ int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
         return 0;
 }
 
         return 0;
 }
 

-int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
-        int r;
-        _cleanup_free_ char *line = NULL;
-        const char *p;
-
-        assert(pid >= 0);
-        assert(st);
-
-        p = procfs_file_alloca(pid, "stat");
-        r = read_one_line_file(p, &line);
-        if (r < 0)
-                return r;
-
-        /* 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 */
-
-        p = strrchr(line, ')');
-        if (!p)
-                return -EIO;
-
-        p++;
-
-        if (sscanf(p, " "
-                   "%*c "  /* state */
-                   "%*d "  /* ppid */
-                   "%*d "  /* pgrp */
-                   "%*d "  /* session */
-                   "%*d "  /* tty_nr */
-                   "%*d "  /* tpgid */
-                   "%*u "  /* flags */
-                   "%*u "  /* minflt */
-                   "%*u "  /* cminflt */
-                   "%*u "  /* majflt */
-                   "%*u "  /* cmajflt */
-                   "%*u "  /* utime */
-                   "%*u "  /* stime */
-                   "%*d "  /* cutime */
-                   "%*d "  /* cstime */
-                   "%*d "  /* priority */
-                   "%*d "  /* nice */
-                   "%*d "  /* num_threads */
-                   "%*d "  /* itrealvalue */
-                   "%llu "  /* starttime */,
-                   st) != 1)
-                return -EIO;
-
-        return 0;
-}
-

 int fchmod_umask(int fd, mode_t m) {
         mode_t u;
         int r;
 int fchmod_umask(int fd, mode_t m) {
         mode_t u;
         int r;


@@ -955,7 +905,7 @@ int get_process_root(pid_t pid, char **root) {
         return get_process_link_contents(p, root);
 }
 
         return get_process_link_contents(p, root);
 }
 

-int get_process_environ(pid_t pid, char **environ) {
+int get_process_environ(pid_t pid, char **env) {

         _cleanup_fclose_ FILE *f = NULL;
         _cleanup_free_ char *outcome = NULL;
         int c;
         _cleanup_fclose_ FILE *f = NULL;
         _cleanup_free_ char *outcome = NULL;
         int c;


@@ -963,7 +913,7 @@ int get_process_environ(pid_t pid, char **environ) {
         size_t allocated = 0, sz = 0;
 
         assert(pid >= 0);
         size_t allocated = 0, sz = 0;
 
         assert(pid >= 0);

-        assert(environ);
+        assert(env);

 
         p = procfs_file_alloca(pid, "environ");
 
 
         p = procfs_file_alloca(pid, "environ");
 


@@ -982,7 +932,7 @@ int get_process_environ(pid_t pid, char **environ) {
         }
 
         outcome[sz] = '\0';
         }
 
         outcome[sz] = '\0';

-        *environ = outcome;
+        *env = outcome;

         outcome = NULL;
 
         return 0;
         outcome = NULL;
 
         return 0;


@@ -1486,7 +1436,7 @@ char *cunescape_length_with_prefix(const char *s, size_t length, const char *pre
                 }
 
                 case 0:
                 }
 
                 case 0:

-                        /* premature end of string.*/
+                        /* premature end of string. */

                         *(t++) = '\\';
                         goto finish;
 
                         *(t++) = '\\';
                         goto finish;
 


@@ -2150,9 +2100,9 @@ int acquire_terminal(
                 assert(notify >= 0);
 
                 for (;;) {
                 assert(notify >= 0);
 
                 for (;;) {

-                        uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
-                        ssize_t l;
+                        uint8_t buffer[INOTIFY_EVENT_MAX] _alignas_(struct inotify_event);

                         struct inotify_event *e;
                         struct inotify_event *e;

+                        ssize_t l;

 
                         if (timeout != USEC_INFINITY) {
                                 usec_t n;
 
                         if (timeout != USEC_INFINITY) {
                                 usec_t n;


@@ -2173,9 +2123,8 @@ int acquire_terminal(
                                 }
                         }
 
                                 }
                         }
 

-                        l = read(notify, inotify_buffer, sizeof(inotify_buffer));
+                        l = read(notify, buffer, sizeof(buffer));

                         if (l < 0) {
                         if (l < 0) {

-

                                 if (errno == EINTR || errno == EAGAIN)
                                         continue;
 
                                 if (errno == EINTR || errno == EAGAIN)
                                         continue;
 


@@ -2183,21 +2132,11 @@ int acquire_terminal(
                                 goto fail;
                         }
 
                                 goto fail;
                         }
 

-                        e = (struct inotify_event*) inotify_buffer;
-
-                        while (l > 0) {
-                                size_t step;
-
+                        FOREACH_INOTIFY_EVENT(e, buffer, l) {

                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
                                         r = -EIO;
                                         goto fail;
                                 }
                                 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;
                         }
 
                         break;


@@ -2353,13 +2292,15 @@ ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
         return n;
 }
 
         return n;
 }
 

-ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
+int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {

         const uint8_t *p = buf;
         ssize_t n = 0;
 
         assert(fd >= 0);
         assert(buf);
 
         const uint8_t *p = buf;
         ssize_t n = 0;
 
         assert(fd >= 0);
         assert(buf);
 

+        errno = 0;
+

         while (nbytes > 0) {
                 ssize_t k;
 
         while (nbytes > 0) {
                 ssize_t k;
 


@@ -2378,14 +2319,15 @@ ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
                 }
 
                 if (k <= 0)
                 }
 
                 if (k <= 0)

-                        return n > 0 ? n : (k < 0 ? -errno : 0);
+                        /* We were not done yet, and a write error occured. */
+                        return errno ? -errno : -EIO;

 
                 p += k;
                 nbytes -= k;
                 n += k;
         }
 
 
                 p += k;
                 nbytes -= k;
                 n += k;
         }
 

-        return n;
+        return 0;

 }
 
 int parse_size(const char *t, off_t base, off_t *size) {
 }
 
 int parse_size(const char *t, off_t base, off_t *size) {


@@ -3052,6 +2994,15 @@ _pure_ static int is_temporary_fs(struct statfs *s) {
                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
 }
 
                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
 }
 

+int is_fd_on_temporary_fs(int fd) {
+        struct statfs s;
+
+        if (fstatfs(fd, &s) < 0)
+                return -errno;
+
+        return is_temporary_fs(&s);
+}
+

 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
         struct statfs s;
 
 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
         struct statfs s;
 


@@ -3167,11 +3118,11 @@ int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
          * first change the access mode and only then hand out
          * ownership to avoid a window where access is too open. */
 
          * first change the access mode and only then hand out
          * ownership to avoid a window where access is too open. */
 

-        if (mode != (mode_t) -1)
+        if (mode != MODE_INVALID)

                 if (chmod(path, mode) < 0)
                         return -errno;
 
                 if (chmod(path, mode) < 0)
                         return -errno;
 

-        if (uid != (uid_t) -1 || gid != (gid_t) -1)
+        if (uid != UID_INVALID || gid != GID_INVALID)

                 if (chown(path, uid, gid) < 0)
                         return -errno;
 
                 if (chown(path, uid, gid) < 0)
                         return -errno;
 


@@ -3185,11 +3136,11 @@ int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
          * first change the access mode and only then hand out
          * ownership to avoid a window where access is too open. */
 
          * first change the access mode and only then hand out
          * ownership to avoid a window where access is too open. */
 

-        if (mode != (mode_t) -1)
+        if (mode != MODE_INVALID)

                 if (fchmod(fd, mode) < 0)
                         return -errno;
 
                 if (fchmod(fd, mode) < 0)
                         return -errno;
 

-        if (uid != (uid_t) -1 || gid != (gid_t) -1)
+        if (uid != UID_INVALID || gid != GID_INVALID)

                 if (fchown(fd, uid, gid) < 0)
                         return -errno;
 
                 if (fchown(fd, uid, gid) < 0)
                         return -errno;
 


@@ -3680,7 +3631,7 @@ int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gi
                         return -errno;
         }
 
                         return -errno;
         }
 

-        if (uid != (uid_t) -1 || gid != (gid_t) -1) {
+        if (uid != UID_INVALID || gid != GID_INVALID) {

                 r = fchown(fd, uid, gid);
                 if (r < 0)
                         return -errno;
                 r = fchown(fd, uid, gid);
                 if (r < 0)
                         return -errno;


@@ -3701,7 +3652,7 @@ int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gi
 }
 
 int touch(const char *path) {
 }
 
 int touch(const char *path) {

-        return touch_file(path, false, USEC_INFINITY, (uid_t) -1, (gid_t) -1, 0);
+        return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);

 }
 
 char *unquote(const char *s, const char* quotes) {
 }
 
 char *unquote(const char *s, const char* quotes) {


@@ -3711,7 +3662,7 @@ char *unquote(const char *s, const char* quotes) {
         /* This is rather stupid, simply removes the heading and
          * trailing quotes if there is one. Doesn't care about
          * escaping or anything. We should make this smarter one
         /* This is rather stupid, simply removes the heading and
          * trailing quotes if there is one. Doesn't care about
          * escaping or anything. We should make this smarter one

-         * day...*/
+         * day... */

 
         l = strlen(s);
         if (l < 2)
 
         l = strlen(s);
         if (l < 2)


@@ -3786,8 +3737,11 @@ int wait_for_terminate(pid_t pid, siginfo_t *status) {
  *
  * That is, success is indicated by a return value of zero, and an
  * error is indicated by a non-zero value.
  *
  * That is, success is indicated by a return value of zero, and an
  * error is indicated by a non-zero value.

+ *
+ * A warning is emitted if the process terminates abnormally,
+ * and also if it returns non-zero unless check_exit_code is true.

  */
  */

-int wait_for_terminate_and_warn(const char *name, pid_t pid) {
+int wait_for_terminate_and_warn(const char *name, pid_t pid, bool check_exit_code) {

         int r;
         siginfo_t status;
 
         int r;
         siginfo_t status;
 


@@ -3799,14 +3753,13 @@ int wait_for_terminate_and_warn(const char *name, pid_t pid) {
                 return log_warning_errno(r, "Failed to wait for %s: %m", name);
 
         if (status.si_code == CLD_EXITED) {
                 return log_warning_errno(r, "Failed to wait for %s: %m", name);
 
         if (status.si_code == CLD_EXITED) {

-                if (status.si_status != 0) {
-                        log_warning("%s failed with error code %i.", name, status.si_status);
-                        return status.si_status;
-                }
-
-                log_debug("%s succeeded.", name);
-                return 0;
+                if (status.si_status != 0)
+                        log_full(check_exit_code ? LOG_WARNING : LOG_DEBUG,
+                                 "%s failed with error code %i.", name, status.si_status);
+                else
+                        log_debug("%s succeeded.", name);

 
 

+                return status.si_status;

         } else if (status.si_code == CLD_KILLED ||
                    status.si_code == CLD_DUMPED) {
 
         } else if (status.si_code == CLD_KILLED ||
                    status.si_code == CLD_DUMPED) {
 


@@ -4161,13 +4114,13 @@ void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv
                         path = hashmap_remove(pids, UINT_TO_PTR(pid));
                         assert(path);
 
                         path = hashmap_remove(pids, UINT_TO_PTR(pid));
                         assert(path);
 

-                        wait_for_terminate_and_warn(path, pid);
+                        wait_for_terminate_and_warn(path, pid, true);

                 }
 
                 _exit(EXIT_SUCCESS);
         }
 
                 }
 
                 _exit(EXIT_SUCCESS);
         }
 

-        wait_for_terminate_and_warn(directory, executor_pid);
+        wait_for_terminate_and_warn(directory, executor_pid, true);

 }
 
 int kill_and_sigcont(pid_t pid, int sig) {
 }
 
 int kill_and_sigcont(pid_t pid, int sig) {


@@ -4331,15 +4284,15 @@ int fd_wait_for_event(int fd, int event, usec_t t) {
 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
         FILE *f;
         char *t;
 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
         FILE *f;
         char *t;

-        int fd;
+        int r, fd;

 
         assert(path);
         assert(_f);
         assert(_temp_path);
 
 
         assert(path);
         assert(_f);
         assert(_temp_path);
 

-        t = tempfn_xxxxxx(path);
-        if (!t)
-                return -ENOMEM;
+        r = tempfn_xxxxxx(path, &t);
+        if (r < 0)
+                return r;

 
         fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
         if (fd < 0) {
 
         fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
         if (fd < 0) {


@@ -4450,13 +4403,14 @@ int vt_disallocate(const char *name) {
 
 int symlink_atomic(const char *from, const char *to) {
         _cleanup_free_ char *t = NULL;
 
 int symlink_atomic(const char *from, const char *to) {
         _cleanup_free_ char *t = NULL;

+        int r;

 
         assert(from);
         assert(to);
 
 
         assert(from);
         assert(to);
 

-        t = tempfn_random(to);
-        if (!t)
-                return -ENOMEM;
+        r = tempfn_random(to, &t);
+        if (r < 0)
+                return r;

 
         if (symlink(from, t) < 0)
                 return -errno;
 
         if (symlink(from, t) < 0)
                 return -errno;


@@ -4471,12 +4425,13 @@ int symlink_atomic(const char *from, const char *to) {
 
 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
         _cleanup_free_ char *t = NULL;
 
 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
         _cleanup_free_ char *t = NULL;

+        int r;

 
         assert(path);
 
 
         assert(path);
 

-        t = tempfn_random(path);
-        if (!t)
-                return -ENOMEM;
+        r = tempfn_random(path, &t);
+        if (r < 0)
+                return r;

 
         if (mknod(t, mode, dev) < 0)
                 return -errno;
 
         if (mknod(t, mode, dev) < 0)
                 return -errno;


@@ -4491,12 +4446,13 @@ int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
 
 int mkfifo_atomic(const char *path, mode_t mode) {
         _cleanup_free_ char *t = NULL;
 
 int mkfifo_atomic(const char *path, mode_t mode) {
         _cleanup_free_ char *t = NULL;

+        int r;

 
         assert(path);
 
 
         assert(path);
 

-        t = tempfn_random(path);
-        if (!t)
-                return -ENOMEM;
+        r = tempfn_random(path, &t);
+        if (r < 0)
+                return r;

 
         if (mkfifo(t, mode) < 0)
                 return -errno;
 
         if (mkfifo(t, mode) < 0)
                 return -errno;


@@ -5608,7 +5564,7 @@ int get_shell(char **_s) {
         return 0;
 }
 
         return 0;
 }
 

-bool filename_is_safe(const char *p) {
+bool filename_is_valid(const char *p) {

 
         if (isempty(p))
                 return false;
 
         if (isempty(p))
                 return false;


@@ -6547,9 +6503,9 @@ int getpeercred(int fd, struct ucred *ucred) {
          * to namespacing issues */
         if (u.pid <= 0)
                 return -ENODATA;
          * to namespacing issues */
         if (u.pid <= 0)
                 return -ENODATA;

-        if (u.uid == (uid_t) -1)
+        if (u.uid == UID_INVALID)

                 return -ENODATA;
                 return -ENODATA;

-        if (u.gid == (gid_t) -1)
+        if (u.gid == GID_INVALID)

                 return -ENODATA;
 
         *ucred = u;
                 return -ENODATA;
 
         *ucred = u;


@@ -7010,42 +6966,45 @@ int fflush_and_check(FILE *f) {
         return 0;
 }
 
         return 0;
 }
 

-char *tempfn_xxxxxx(const char *p) {
+int tempfn_xxxxxx(const char *p, char **ret) {

         const char *fn;
         char *t;
         const char *fn;
         char *t;

-        size_t k;

 
         assert(p);
 
         assert(p);

+        assert(ret);
+
+        fn = basename(p);
+        if (!filename_is_valid(fn))
+                return -EINVAL;

 
         t = new(char, strlen(p) + 1 + 6 + 1);
         if (!t)
 
         t = new(char, strlen(p) + 1 + 6 + 1);
         if (!t)

-                return NULL;
-
-        fn = basename(p);
-        k = fn - p;
+                return -ENOMEM;

 
 

-        strcpy(stpcpy(stpcpy(mempcpy(t, p, k), "."), fn), "XXXXXX");
+        strcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), "."), fn), "XXXXXX");

 
 

-        return t;
+        *ret = t;
+        return 0;

 }
 
 }
 

-char *tempfn_random(const char *p) {
+int tempfn_random(const char *p, char **ret) {

         const char *fn;
         char *t, *x;
         uint64_t u;
         const char *fn;
         char *t, *x;
         uint64_t u;

-        size_t k;

         unsigned i;
 
         assert(p);
         unsigned i;
 
         assert(p);

+        assert(ret);
+
+        fn = basename(p);
+        if (!filename_is_valid(fn))
+                return -EINVAL;

 
         t = new(char, strlen(p) + 1 + 16 + 1);
         if (!t)
 
         t = new(char, strlen(p) + 1 + 16 + 1);
         if (!t)

-                return NULL;
-
-        fn = basename(p);
-        k = fn - p;
+                return -ENOMEM;

 
 

-        x = stpcpy(stpcpy(mempcpy(t, p, k), "."), fn);
+        x = stpcpy(stpcpy(mempcpy(t, p, fn - p), "."), fn);

 
         u = random_u64();
         for (i = 0; i < 16; i++) {
 
         u = random_u64();
         for (i = 0; i < 16; i++) {


@@ -7055,7 +7014,8 @@ char *tempfn_random(const char *p) {
 
         *x = 0;
 
 
         *x = 0;
 

-        return t;
+        *ret = t;
+        return 0;

 }
 
 /* make sure the hostname is not "localhost" */
 }
 
 /* make sure the hostname is not "localhost" */