gdbsupport/fileio.cc

   1 /* File-I/O functions for GDB, the GNU debugger.
   2
   3    Copyright (C) 2003-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "fileio.h"
  21 #include <sys/stat.h>
  22 #include <fcntl.h>
  23
  24 /* See fileio.h.  */
  25
  26 fileio_error
  27 host_to_fileio_error (int error)
  28 {
  29   switch (error)
  30     {
  31       case EPERM:
  32         return FILEIO_EPERM;
  33       case ENOENT:
  34         return FILEIO_ENOENT;
  35       case EINTR:
  36         return FILEIO_EINTR;
  37       case EIO:
  38         return FILEIO_EIO;
  39       case EBADF:
  40         return FILEIO_EBADF;
  41       case EACCES:
  42         return FILEIO_EACCES;
  43       case EFAULT:
  44         return FILEIO_EFAULT;
  45       case EBUSY:
  46         return FILEIO_EBUSY;
  47       case EEXIST:
  48         return FILEIO_EEXIST;
  49       case ENODEV:
  50         return FILEIO_ENODEV;
  51       case ENOTDIR:
  52         return FILEIO_ENOTDIR;
  53       case EISDIR:
  54         return FILEIO_EISDIR;
  55       case EINVAL:
  56         return FILEIO_EINVAL;
  57       case ENFILE:
  58         return FILEIO_ENFILE;
  59       case EMFILE:
  60         return FILEIO_EMFILE;
  61       case EFBIG:
  62         return FILEIO_EFBIG;
  63       case ENOSPC:
  64         return FILEIO_ENOSPC;
  65       case ESPIPE:
  66         return FILEIO_ESPIPE;
  67       case EROFS:
  68         return FILEIO_EROFS;
  69       case ENOSYS:
  70         return FILEIO_ENOSYS;
  71       case ENAMETOOLONG:
  72         return FILEIO_ENAMETOOLONG;
  73     }
  74   return FILEIO_EUNKNOWN;
  75 }
  76
  77 /* See fileio.h.  */
  78
  79 int
  80 fileio_error_to_host (fileio_error errnum)
  81 {
  82   switch (errnum)
  83     {
  84       case FILEIO_EPERM:
  85         return EPERM;
  86       case FILEIO_ENOENT:
  87         return ENOENT;
  88       case FILEIO_EINTR:
  89         return EINTR;
  90       case FILEIO_EIO:
  91         return EIO;
  92       case FILEIO_EBADF:
  93         return EBADF;
  94       case FILEIO_EACCES:
  95         return EACCES;
  96       case FILEIO_EFAULT:
  97         return EFAULT;
  98       case FILEIO_EBUSY:
  99         return EBUSY;
 100       case FILEIO_EEXIST:
 101         return EEXIST;
 102       case FILEIO_ENODEV:
 103         return ENODEV;
 104       case FILEIO_ENOTDIR:
 105         return ENOTDIR;
 106       case FILEIO_EISDIR:
 107         return EISDIR;
 108       case FILEIO_EINVAL:
 109         return EINVAL;
 110       case FILEIO_ENFILE:
 111         return ENFILE;
 112       case FILEIO_EMFILE:
 113         return EMFILE;
 114       case FILEIO_EFBIG:
 115         return EFBIG;
 116       case FILEIO_ENOSPC:
 117         return ENOSPC;
 118       case FILEIO_ESPIPE:
 119         return ESPIPE;
 120       case FILEIO_EROFS:
 121         return EROFS;
 122       case FILEIO_ENOSYS:
 123         return ENOSYS;
 124       case FILEIO_ENAMETOOLONG:
 125         return ENAMETOOLONG;
 126     }
 127   return -1;
 128 }
 129
 130 /* See fileio.h.  */
 131
 132 int
 133 fileio_to_host_openflags (int fileio_open_flags, int *open_flags_p)
 134 {
 135   int open_flags = 0;
 136
 137   if (fileio_open_flags & ~FILEIO_O_SUPPORTED)
 138     return -1;
 139
 140   if (fileio_open_flags & FILEIO_O_CREAT)
 141     open_flags |= O_CREAT;
 142   if (fileio_open_flags & FILEIO_O_EXCL)
 143     open_flags |= O_EXCL;
 144   if (fileio_open_flags & FILEIO_O_TRUNC)
 145     open_flags |= O_TRUNC;
 146   if (fileio_open_flags & FILEIO_O_APPEND)
 147     open_flags |= O_APPEND;
 148   if (fileio_open_flags & FILEIO_O_RDONLY)
 149     open_flags |= O_RDONLY;
 150   if (fileio_open_flags & FILEIO_O_WRONLY)
 151     open_flags |= O_WRONLY;
 152   if (fileio_open_flags & FILEIO_O_RDWR)
 153     open_flags |= O_RDWR;
 154   /* On systems supporting binary and text mode, always open files
 155      in binary mode. */
 156 #ifdef O_BINARY
 157   open_flags |= O_BINARY;
 158 #endif
 159
 160   *open_flags_p = open_flags;
 161   return 0;
 162 }
 163
 164 /* See fileio.h.  */
 165
 166 int
 167 fileio_to_host_mode (int fileio_mode, mode_t *mode_p)
 168 {
 169   mode_t mode = 0;
 170
 171   if (fileio_mode & ~FILEIO_S_SUPPORTED)
 172     return -1;
 173
 174   if (fileio_mode & FILEIO_S_IFREG)
 175     mode |= S_IFREG;
 176   if (fileio_mode & FILEIO_S_IFDIR)
 177     mode |= S_IFDIR;
 178   if (fileio_mode & FILEIO_S_IFCHR)
 179     mode |= S_IFCHR;
 180   if (fileio_mode & FILEIO_S_IRUSR)
 181     mode |= S_IRUSR;
 182   if (fileio_mode & FILEIO_S_IWUSR)
 183     mode |= S_IWUSR;
 184   if (fileio_mode & FILEIO_S_IXUSR)
 185     mode |= S_IXUSR;
 186 #ifdef S_IRGRP
 187   if (fileio_mode & FILEIO_S_IRGRP)
 188     mode |= S_IRGRP;
 189 #endif
 190 #ifdef S_IWGRP
 191   if (fileio_mode & FILEIO_S_IWGRP)
 192     mode |= S_IWGRP;
 193 #endif
 194 #ifdef S_IXGRP
 195   if (fileio_mode & FILEIO_S_IXGRP)
 196     mode |= S_IXGRP;
 197 #endif
 198   if (fileio_mode & FILEIO_S_IROTH)
 199     mode |= S_IROTH;
 200 #ifdef S_IWOTH
 201   if (fileio_mode & FILEIO_S_IWOTH)
 202     mode |= S_IWOTH;
 203 #endif
 204 #ifdef S_IXOTH
 205   if (fileio_mode & FILEIO_S_IXOTH)
 206     mode |= S_IXOTH;
 207 #endif
 208
 209   *mode_p = mode;
 210   return 0;
 211 }
 212
 213 /* Convert a host-format mode_t into a bitmask of File-I/O flags.  */
 214
 215 static LONGEST
 216 fileio_mode_pack (mode_t mode)
 217 {
 218   mode_t tmode = 0;
 219
 220   if (S_ISREG (mode))
 221     tmode |= FILEIO_S_IFREG;
 222   if (S_ISDIR (mode))
 223     tmode |= FILEIO_S_IFDIR;
 224   if (S_ISCHR (mode))
 225     tmode |= FILEIO_S_IFCHR;
 226   if (mode & S_IRUSR)
 227     tmode |= FILEIO_S_IRUSR;
 228   if (mode & S_IWUSR)
 229     tmode |= FILEIO_S_IWUSR;
 230   if (mode & S_IXUSR)
 231     tmode |= FILEIO_S_IXUSR;
 232 #ifdef S_IRGRP
 233   if (mode & S_IRGRP)
 234     tmode |= FILEIO_S_IRGRP;
 235 #endif
 236 #ifdef S_IWGRP
 237   if (mode & S_IWGRP)
 238     tmode |= FILEIO_S_IWGRP;
 239 #endif
 240 #ifdef S_IXGRP
 241   if (mode & S_IXGRP)
 242     tmode |= FILEIO_S_IXGRP;
 243 #endif
 244   if (mode & S_IROTH)
 245     tmode |= FILEIO_S_IROTH;
 246 #ifdef S_IWOTH
 247   if (mode & S_IWOTH)
 248     tmode |= FILEIO_S_IWOTH;
 249 #endif
 250 #ifdef S_IXOTH
 251   if (mode & S_IXOTH)
 252     tmode |= FILEIO_S_IXOTH;
 253 #endif
 254   return tmode;
 255 }
 256
 257 /* Pack a host-format mode_t into an fio_mode_t.  */
 258
 259 static void
 260 host_to_fileio_mode (mode_t num, fio_mode_t fnum)
 261 {
 262   host_to_bigendian (fileio_mode_pack (num), (char *) fnum, 4);
 263 }
 264
 265 /* Pack a host-format integer into an fio_ulong_t.  */
 266
 267 static void
 268 host_to_fileio_ulong (LONGEST num, fio_ulong_t fnum)
 269 {
 270   host_to_bigendian (num, (char *) fnum, 8);
 271 }
 272
 273 /* See fileio.h.  */
 274
 275 void
 276 host_to_fileio_stat (struct stat *st, struct fio_stat *fst)
 277 {
 278   LONGEST blksize;
 279
 280   host_to_fileio_uint ((long) st->st_dev, fst->fst_dev);
 281   host_to_fileio_uint ((long) st->st_ino, fst->fst_ino);
 282   host_to_fileio_mode (st->st_mode, fst->fst_mode);
 283   host_to_fileio_uint ((long) st->st_nlink, fst->fst_nlink);
 284   host_to_fileio_uint ((long) st->st_uid, fst->fst_uid);
 285   host_to_fileio_uint ((long) st->st_gid, fst->fst_gid);
 286   host_to_fileio_uint ((long) st->st_rdev, fst->fst_rdev);
 287   host_to_fileio_ulong ((LONGEST) st->st_size, fst->fst_size);
 288 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
 289   blksize = st->st_blksize;
 290 #else
 291   blksize = 512;
 292 #endif
 293   host_to_fileio_ulong (blksize, fst->fst_blksize);
 294 #if HAVE_STRUCT_STAT_ST_BLOCKS
 295   host_to_fileio_ulong ((LONGEST) st->st_blocks, fst->fst_blocks);
 296 #else
 297   /* FIXME: This is correct for DJGPP, but other systems that don't
 298      have st_blocks, if any, might prefer 512 instead of st_blksize.
 299      (eliz, 30-12-2003)  */
 300   host_to_fileio_ulong (((LONGEST) st->st_size + blksize - 1)
 301                         / blksize,
 302                         fst->fst_blocks);
 303 #endif
 304   host_to_fileio_time (st->st_atime, fst->fst_atime);
 305   host_to_fileio_time (st->st_mtime, fst->fst_mtime);
 306   host_to_fileio_time (st->st_ctime, fst->fst_ctime);
 307 }