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     initialized = 1;
  38     tracked_fds_count = 0;
  39
  40     const char *env = getenv(ENV_NAME_FDS);
  41     if (!env) {
  42         return;
  43     }
  44     /* Environment is read-only. */
  45     char *env_copy = strdup(env);
  46     if (!env_copy) {
  47         return;
  48     }
  49
  50     char *x;
  51
  52     size_t count = 0;
  53     for (x = env_copy; *x; x++) {
  54         if (*x == ',') {
  55             count++;
  56         }
  57     }
  58     tracked_fds_space = count + TRACKFDS_REALLOC_STEP;
  59
  60     tracked_fds = malloc(tracked_fds_space * sizeof(*tracked_fds));
  61     if (!tracked_fds) {
  62         free(env_copy);
  63         return;
  64     }
  65
  66     size_t i = 0;
  67
  68     /* Parse file descriptor numbers from environment string and store them as
  69      * integers in tracked_fds. */
  70     char *last;
  71     for (x = env_copy, last = env_copy; *x; x++) {
  72         if (*x != ',') {
  73             continue;
  74         }
  75         /* ',' at the beginning or double ',' - ignore. */
  76         if (x == last) {
  77             last = x + 1;
  78             continue;
  79         }
  80
  81         if (i == count) {
  82             break;
  83         }
  84
  85         *x = 0;
  86         tracked_fds[i++] = atoi(last);
  87
  88         last = x + 1;
  89     }
  90
  91     tracked_fds_count = count;
  92
  93     free(env_copy);
  94 }
  95
  96 static void update_environment(void) {
  97     /* An integer (32-bit) has at most 10 digits, + 1 for the comma after each
  98      * number. Bigger file descriptors (which shouldn't occur in reality) are
  99      * truncated. */
 100     char env[tracked_fds_count * (10 + 1) * sizeof(char)];
 101     char *x = env;
 102
 103     size_t i;
 104     for (i = 0; i < tracked_fds_count; i++) {
 105         int length = snprintf(x, 10 + 1, "%d", tracked_fds[i]);
 106         if (length >= 10 + 1)
 107             return;
 108
 109         /* Write comma after number. */
 110         x += length;
 111         *x++ = ',';
 112         /* Make sure the string is always zero terminated. */
 113         *x = 0;
 114     }
 115
 116     setenv(ENV_NAME_FDS, env, 1 /* overwrite */);
 117 }
 118
 119
 120 #ifdef DEBUG
 121 static void tracked_fds_debug(void) {
 122     debug("tracked_fds: %d/%d\t[%d]\n", tracked_fds_count, tracked_fds_space,
 123                                         getpid());
 124     size_t i;
 125     for (i = 0; i < tracked_fds_count; i++) {
 126         debug("tracked_fds[%d]: %d\n", i, tracked_fds[i]);
 127     }
 128 }
 129 #endif
 130
 131 static void tracked_fds_add(int fd) {
 132     if (tracked_fds_count >= tracked_fds_space) {
 133         size_t new_space = tracked_fds_space + TRACKFDS_REALLOC_STEP;
 134         if (!realloc(tracked_fds, sizeof(*tracked_fds) * new_space)) {
 135             /* We can do nothing, just ignore the error. We made sure not to
 136              * destroy our state, so the new descriptor is ignored without any
 137              * other consequences. */
 138             return;
 139         }
 140         tracked_fds_space = new_space;
 141     }
 142
 143     tracked_fds[tracked_fds_count++] = fd;
 144
 145 #ifdef DEBUG
 146     tracked_fds_debug();
 147 #endif
 148 }
 149 static int tracked_fds_remove(int fd) {
 150     size_t i;
 151     for (i = 0; i < tracked_fds_count; i++) {
 152         if (fd != tracked_fds[i]) {
 153             continue;
 154         }
 155
 156         memmove(tracked_fds + i, tracked_fds + i + 1,
 157                 sizeof(*tracked_fds) * (tracked_fds_count - i - 1));
 158         tracked_fds_count--;
 159
 160 #ifdef DEBUG
 161         tracked_fds_debug();
 162 #endif
 163
 164         /* Found. */
 165         return 1;
 166     }
 167
 168     /* Not found. */
 169     return 0;
 170 }
 171 static int tracked_fds_find(int fd) {
 172     size_t i;
 173     for (i = 0; i < tracked_fds_count; i++) {
 174         if (fd == tracked_fds[i]) {
 175             return 1;
 176         }
 177     }
 178     return 0;
 179 }
 180
 181 #endif