src/trackfds.h

   1 /*
   2  * Utility functions to track file descriptors.
   3  *
   4  * Copyright (C) 2013  Simon Ruderich
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifndef TRACKFDS_H
  21 #define TRACKFDS_H 1
  22
  23 /* List of tracked file descriptors. */
  24 static int *tracked_fds;
  25 /* Current number of items in the list. */
  26 static size_t tracked_fds_count;
  27 /* Allocated items, used to reduce realloc()s. */
  28 static size_t tracked_fds_space;
  29
  30
  31 /* Load tracked file descriptors from the environment. The environment is used
  32  * to pass the information to child processes.
  33  *
  34  * ENV_NAME_FDS has the following format: Each descriptor as string followed
  35  * by a comma; there's a trailing comma. Example: "2,4,". */
  36 static void init_from_environment(void) {
  37     const char *env;
  38
  39     initialized = 1;
  40     tracked_fds_count = 0;
  41
  42     /* If ENV_NAME_FORCE_WRITE is set and not empty, allow writes to a non-tty
  43      * device. Use with care! Mainly used for the test suite. */
  44     env = getenv(ENV_NAME_FORCE_WRITE);
  45     if (env && env[0] != '\0') {
  46         force_write_to_non_tty = 1;
  47     }
  48
  49     env = getenv(ENV_NAME_FDS);
  50     if (!env) {
  51         return;
  52     }
  53     /* Environment is read-only. */
  54     char *env_copy = strdup(env);
  55     if (!env_copy) {
  56         return;
  57     }
  58
  59     char *x;
  60
  61     size_t count = 0;
  62     for (x = env_copy; *x; x++) {
  63         if (*x == ',') {
  64             count++;
  65         }
  66     }
  67     tracked_fds_space = count + TRACKFDS_REALLOC_STEP;
  68
  69     tracked_fds = malloc(tracked_fds_space * sizeof(*tracked_fds));
  70     if (!tracked_fds) {
  71         free(env_copy);
  72         return;
  73     }
  74
  75     size_t i = 0;
  76
  77     /* Parse file descriptor numbers from environment string and store them as
  78      * integers in tracked_fds. */
  79     char *last;
  80     for (x = env_copy, last = env_copy; *x; x++) {
  81         if (*x != ',') {
  82             continue;
  83         }
  84         /* ',' at the beginning or double ',' - ignore. */
  85         if (x == last) {
  86             last = x + 1;
  87             continue;
  88         }
  89
  90         if (i == count) {
  91             break;
  92         }
  93
  94         *x = 0;
  95         tracked_fds[i++] = atoi(last);
  96
  97         last = x + 1;
  98     }
  99
 100     tracked_fds_count = count;
 101
 102     free(env_copy);
 103 }
 104
 105 static void update_environment(void) {
 106     /* An integer (32-bit) has at most 10 digits, + 1 for the comma after each
 107      * number. Bigger file descriptors (which shouldn't occur in reality) are
 108      * truncated. */
 109     char env[tracked_fds_count * (10 + 1) * sizeof(char)];
 110     char *x = env;
 111
 112     size_t i;
 113     for (i = 0; i < tracked_fds_count; i++) {
 114         int length = snprintf(x, 10 + 1, "%d", tracked_fds[i]);
 115         if (length >= 10 + 1)
 116             return;
 117
 118         /* Write comma after number. */
 119         x += length;
 120         *x++ = ',';
 121         /* Make sure the string is always zero terminated. */
 122         *x = 0;
 123     }
 124
 125     setenv(ENV_NAME_FDS, env, 1 /* overwrite */);
 126 }
 127
 128
 129 #ifdef DEBUG
 130 static void tracked_fds_debug(void) {
 131     debug("tracked_fds: %d/%d\t[%d]\n", tracked_fds_count, tracked_fds_space,
 132                                         getpid());
 133     size_t i;
 134     for (i = 0; i < tracked_fds_count; i++) {
 135         debug("tracked_fds[%d]: %d\n", i, tracked_fds[i]);
 136     }
 137 }
 138 #endif
 139
 140 static void tracked_fds_add(int fd) {
 141     if (tracked_fds_count >= tracked_fds_space) {
 142         size_t new_space = tracked_fds_space + TRACKFDS_REALLOC_STEP;
 143         if (!realloc(tracked_fds, sizeof(*tracked_fds) * new_space)) {
 144             /* We can do nothing, just ignore the error. We made sure not to
 145              * destroy our state, so the new descriptor is ignored without any
 146              * other consequences. */
 147             return;
 148         }
 149         tracked_fds_space = new_space;
 150     }
 151
 152     tracked_fds[tracked_fds_count++] = fd;
 153
 154 #ifdef DEBUG
 155     tracked_fds_debug();
 156 #endif
 157 }
 158 static int tracked_fds_remove(int fd) {
 159     size_t i;
 160     for (i = 0; i < tracked_fds_count; i++) {
 161         if (fd != tracked_fds[i]) {
 162             continue;
 163         }
 164
 165         memmove(tracked_fds + i, tracked_fds + i + 1,
 166                 sizeof(*tracked_fds) * (tracked_fds_count - i - 1));
 167         tracked_fds_count--;
 168
 169 #ifdef DEBUG
 170         tracked_fds_debug();
 171 #endif
 172
 173         /* Found. */
 174         return 1;
 175     }
 176
 177     /* Not found. */
 178     return 0;
 179 }
 180 static int tracked_fds_find(int fd) {
 181     size_t i;
 182     for (i = 0; i < tracked_fds_count; i++) {
 183         if (fd == tracked_fds[i]) {
 184             return 1;
 185         }
 186     }
 187     return 0;
 188 }
 189
 190 #endif