gdb/common/filestuff.c

   1 /* Low-level file-handling.
   2    Copyright (C) 2012-2014 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   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 #ifdef GDBSERVER
  20 #include "server.h"
  21 #else
  22 #include "defs.h"
  23 #include <string.h>
  24 #endif
  25 #include "filestuff.h"
  26 #include "gdb_vecs.h"
  27
  28 #include <string.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33
  34 #ifdef USE_WIN32API
  35 #include <winsock2.h>
  36 #include <windows.h>
  37 #define HAVE_SOCKETS 1
  38 #elif defined HAVE_SYS_SOCKET_H
  39 #include <sys/socket.h>
  40 /* Define HAVE_F_GETFD if we plan to use F_GETFD.  */
  41 #define HAVE_F_GETFD F_GETFD
  42 #define HAVE_SOCKETS 1
  43 #endif
  44
  45 #ifdef HAVE_SYS_RESOURCE_H
  46 #include <sys/resource.h>
  47 #endif /* HAVE_SYS_RESOURCE_H */
  48
  49 #ifndef O_CLOEXEC
  50 #define O_CLOEXEC 0
  51 #endif
  52
  53 #ifndef SOCK_CLOEXEC
  54 #define SOCK_CLOEXEC 0
  55 #endif
  56
  57 \f
  58
  59 #ifndef HAVE_FDWALK
  60
  61 #include <dirent.h>
  62
  63 /* Replacement for fdwalk, if the system doesn't define it.  Walks all
  64    open file descriptors (though this implementation may walk closed
  65    ones as well, depending on the host platform's capabilities) and
  66    call FUNC with ARG.  If FUNC returns non-zero, stops immediately
  67    and returns the same value.  Otherwise, returns zero when
  68    finished.  */
  69
  70 static int
  71 fdwalk (int (*func) (void *, int), void *arg)
  72 {
  73   /* Checking __linux__ isn't great but it isn't clear what would be
  74      better.  There doesn't seem to be a good way to check for this in
  75      configure.  */
  76 #ifdef __linux__
  77   DIR *dir;
  78
  79   dir = opendir ("/proc/self/fd");
  80   if (dir != NULL)
  81     {
  82       struct dirent *entry;
  83       int result = 0;
  84
  85       for (entry = readdir (dir); entry != NULL; entry = readdir (dir))
  86         {
  87           long fd;
  88           char *tail;
  89           int result;
  90
  91           errno = 0;
  92           fd = strtol (entry->d_name, &tail, 10);
  93           if (*tail != '\0' || errno != 0)
  94             continue;
  95           if ((int) fd != fd)
  96             {
  97               /* What can we do here really?  */
  98               continue;
  99             }
 100
 101           if (fd == dirfd (dir))
 102             continue;
 103
 104           result = func (arg, fd);
 105           if (result != 0)
 106             break;
 107         }
 108
 109       closedir (dir);
 110       return result;
 111     }
 112   /* We may fall through to the next case.  */
 113 #endif
 114
 115   {
 116     int max, fd;
 117
 118 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE)
 119     struct rlimit rlim;
 120
 121     if (getrlimit (RLIMIT_NOFILE, &rlim) == 0 && rlim.rlim_max != RLIM_INFINITY)
 122       max = rlim.rlim_max;
 123     else
 124 #endif
 125       {
 126 #ifdef _SC_OPEN_MAX
 127         max = sysconf (_SC_OPEN_MAX);
 128 #else
 129         /* Whoops.  */
 130         return 0;
 131 #endif /* _SC_OPEN_MAX */
 132       }
 133
 134     for (fd = 0; fd < max; ++fd)
 135       {
 136         struct stat sb;
 137         int result;
 138
 139         /* Only call FUNC for open fds.  */
 140         if (fstat (fd, &sb) == -1)
 141           continue;
 142
 143         result = func (arg, fd);
 144         if (result != 0)
 145           return result;
 146       }
 147
 148     return 0;
 149   }
 150 }
 151
 152 #endif /* HAVE_FDWALK */
 153
 154 \f
 155
 156 /* A VEC holding all the fds open when notice_open_fds was called.  We
 157    don't use a hashtab because libiberty isn't linked into gdbserver;
 158    and anyway we don't expect there to be many open fds.  */
 159
 160 static VEC (int) *open_fds;
 161
 162 /* An fdwalk callback function used by notice_open_fds.  It puts the
 163    given file descriptor into the vec.  */
 164
 165 static int
 166 do_mark_open_fd (void *ignore, int fd)
 167 {
 168   VEC_safe_push (int, open_fds, fd);
 169   return 0;
 170 }
 171
 172 /* See filestuff.h.  */
 173
 174 void
 175 notice_open_fds (void)
 176 {
 177   fdwalk (do_mark_open_fd, NULL);
 178 }
 179
 180 /* See filestuff.h.  */
 181
 182 void
 183 mark_fd_no_cloexec (int fd)
 184 {
 185   do_mark_open_fd (NULL, fd);
 186 }
 187
 188 /* See filestuff.h.  */
 189
 190 void
 191 unmark_fd_no_cloexec (int fd)
 192 {
 193   int i, val;
 194
 195   for (i = 0; VEC_iterate (int, open_fds, i, val); ++i)
 196     {
 197       if (fd == val)
 198         {
 199           VEC_unordered_remove (int, open_fds, i);
 200           return;
 201         }
 202     }
 203
 204   gdb_assert_not_reached (_("fd not found in open_fds"));
 205 }
 206
 207 /* Helper function for close_most_fds that closes the file descriptor
 208    if appropriate.  */
 209
 210 static int
 211 do_close (void *ignore, int fd)
 212 {
 213   int i, val;
 214
 215   for (i = 0; VEC_iterate (int, open_fds, i, val); ++i)
 216     {
 217       if (fd == val)
 218         {
 219           /* Keep this one open.  */
 220           return 0;
 221         }
 222     }
 223
 224   close (fd);
 225   return 0;
 226 }
 227
 228 /* See filestuff.h.  */
 229
 230 void
 231 close_most_fds (void)
 232 {
 233   fdwalk (do_close, NULL);
 234 }
 235
 236 \f
 237
 238 /* This is a tri-state flag.  When zero it means we haven't yet tried
 239    O_CLOEXEC.  When positive it means that O_CLOEXEC works on this
 240    host.  When negative, it means that O_CLOEXEC doesn't work.  We
 241    track this state because, while gdb might have been compiled
 242    against a libc that supplies O_CLOEXEC, there is no guarantee that
 243    the kernel supports it.  */
 244
 245 static int trust_o_cloexec;
 246
 247 /* Mark FD as close-on-exec, ignoring errors.  Update
 248    TRUST_O_CLOEXEC.  */
 249
 250 static void
 251 mark_cloexec (int fd)
 252 {
 253 #ifdef HAVE_F_GETFD
 254   int old = fcntl (fd, F_GETFD, 0);
 255
 256   if (old != -1)
 257     {
 258       fcntl (fd, F_SETFD, old | FD_CLOEXEC);
 259
 260       if (trust_o_cloexec == 0)
 261         {
 262           if ((old & FD_CLOEXEC) != 0)
 263             trust_o_cloexec = 1;
 264           else
 265             trust_o_cloexec = -1;
 266         }
 267     }
 268 #endif /* HAVE_F_GETFD */
 269 }
 270
 271 /* Depending on TRUST_O_CLOEXEC, mark FD as close-on-exec.  */
 272
 273 static void
 274 maybe_mark_cloexec (int fd)
 275 {
 276   if (trust_o_cloexec <= 0)
 277     mark_cloexec (fd);
 278 }
 279
 280 #ifdef HAVE_SOCKETS
 281
 282 /* Like maybe_mark_cloexec, but for callers that use SOCK_CLOEXEC.  */
 283
 284 static void
 285 socket_mark_cloexec (int fd)
 286 {
 287   if (SOCK_CLOEXEC == 0 || trust_o_cloexec <= 0)
 288     mark_cloexec (fd);
 289 }
 290
 291 #endif
 292
 293 \f
 294
 295 /* See filestuff.h.  */
 296
 297 int
 298 gdb_open_cloexec (const char *filename, int flags, unsigned long mode)
 299 {
 300   int fd = open (filename, flags | O_CLOEXEC, mode);
 301
 302   if (fd >= 0)
 303     maybe_mark_cloexec (fd);
 304
 305   return fd;
 306 }
 307
 308 /* See filestuff.h.  */
 309
 310 FILE *
 311 gdb_fopen_cloexec (const char *filename, const char *opentype)
 312 {
 313   FILE *result;
 314   /* Probe for "e" support once.  But, if we can tell the operating
 315      system doesn't know about close on exec mode "e" without probing,
 316      skip it.  E.g., the Windows runtime issues an "Invalid parameter
 317      passed to C runtime function" OutputDebugString warning for
 318      unknown modes.  Assume that if O_CLOEXEC is zero, then "e" isn't
 319      supported.  */
 320   static int fopen_e_ever_failed_einval = O_CLOEXEC == 0;
 321
 322   if (!fopen_e_ever_failed_einval)
 323     {
 324       char *copy;
 325
 326       copy = alloca (strlen (opentype) + 2);
 327       strcpy (copy, opentype);
 328       /* This is a glibc extension but we try it unconditionally on
 329          this path.  */
 330       strcat (copy, "e");
 331       result = fopen (filename, copy);
 332
 333       if (result == NULL && errno == EINVAL)
 334         {
 335           result = fopen (filename, opentype);
 336           if (result != NULL)
 337             fopen_e_ever_failed_einval = 1;
 338         }
 339     }
 340   else
 341     result = fopen (filename, opentype);
 342
 343   if (result != NULL)
 344     maybe_mark_cloexec (fileno (result));
 345
 346   return result;
 347 }
 348
 349 #ifdef HAVE_SOCKETS
 350 /* See filestuff.h.  */
 351
 352 int
 353 gdb_socketpair_cloexec (int namespace, int style, int protocol, int filedes[2])
 354 {
 355 #ifdef HAVE_SOCKETPAIR
 356   int result = socketpair (namespace, style | SOCK_CLOEXEC, protocol, filedes);
 357
 358   if (result != -1)
 359     {
 360       socket_mark_cloexec (filedes[0]);
 361       socket_mark_cloexec (filedes[1]);
 362     }
 363
 364   return result;
 365 #else
 366   gdb_assert_not_reached (_("socketpair not available on this host"));
 367 #endif
 368 }
 369
 370 /* See filestuff.h.  */
 371
 372 int
 373 gdb_socket_cloexec (int namespace, int style, int protocol)
 374 {
 375   int result = socket (namespace, style | SOCK_CLOEXEC, protocol);
 376
 377   if (result != -1)
 378     socket_mark_cloexec (result);
 379
 380   return result;
 381 }
 382 #endif
 383
 384 /* See filestuff.h.  */
 385
 386 int
 387 gdb_pipe_cloexec (int filedes[2])
 388 {
 389   int result;
 390
 391 #ifdef HAVE_PIPE2
 392   result = pipe2 (filedes, O_CLOEXEC);
 393   if (result != -1)
 394     {
 395       maybe_mark_cloexec (filedes[0]);
 396       maybe_mark_cloexec (filedes[1]);
 397     }
 398 #else
 399 #ifdef HAVE_PIPE
 400   result = pipe (filedes);
 401   if (result != -1)
 402     {
 403       mark_cloexec (filedes[0]);
 404       mark_cloexec (filedes[1]);
 405     }
 406 #else /* HAVE_PIPE */
 407   gdb_assert_not_reached (_("pipe not available on this host"));
 408 #endif /* HAVE_PIPE */
 409 #endif /* HAVE_PIPE2 */
 410
 411   return result;
 412 }