compiler/clib/__fdesc.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     File descriptors handling internals.
   6 */
   7
   8 #include "__arosc_privdata.h"
   9
  10 #include <string.h>
  11 #include <fcntl.h>
  12 #include <stdlib.h>
  13 #include <unistd.h>
  14 #include <errno.h>
  15
  16 #define DEBUG 0
  17
  18 #include <proto/exec.h>
  19 #include <proto/dos.h>
  20 #include <exec/memory.h>
  21 #include <exec/semaphores.h>
  22 #include <dos/dos.h>
  23 #include <dos/filesystem.h>
  24 #include <aros/symbolsets.h>
  25 #include <aros/debug.h>
  26 #include "__errno.h"
  27 #include "__fdesc.h"
  28 #include "__upath.h"
  29
  30 int __getfdslots(void)
  31 {
  32     return __numslots;
  33 }
  34
  35 fdesc *__getfdesc(register int fd)
  36 {
  37     return ((__numslots>fd) && (fd>=0))?__fd_array[fd]:NULL;
  38 }
  39
  40 void __setfdesc(register int fd, fdesc *desc)
  41 {
  42     /* FIXME: Check if fd is in valid range... */
  43     __fd_array[fd] = desc;
  44 }
  45
  46 int __getfirstfd(register int startfd)
  47 {
  48     /* FIXME: Check if fd is in valid range... */
  49     for (
  50         ;
  51         startfd < __numslots && __fd_array[startfd];
  52         startfd++
  53     );
  54
  55     return startfd;
  56 }
  57
  58 int __getfdslot(int wanted_fd)
  59 {
  60     if (wanted_fd>=__numslots)
  61     {
  62         void *tmp;
  63
  64         tmp = AllocPooled(__fd_mempool, (wanted_fd+1)*sizeof(fdesc *));
  65
  66         if (!tmp) return -1;
  67
  68         if (__fd_array)
  69         {
  70             size_t size = __numslots*sizeof(fdesc *);
  71             CopyMem(__fd_array, tmp, size);
  72             FreePooled(__fd_mempool, __fd_array, size);
  73         }
  74
  75         __fd_array = tmp;
  76
  77         bzero(__fd_array + __numslots, (wanted_fd - __numslots + 1) * sizeof(fdesc *));
  78         __numslots = wanted_fd+1;
  79     }
  80     else if (wanted_fd < 0)
  81     {
  82         errno = EINVAL;
  83         return -1;
  84     }
  85     else if (__fd_array[wanted_fd])
  86     {
  87         close(wanted_fd);
  88     }
  89
  90     return wanted_fd;
  91 }
  92
  93 LONG __oflags2amode(int flags)
  94 {
  95     LONG openmode = 0;
  96
  97     /* filter out invalid modes */
  98     switch (flags & (O_CREAT|O_TRUNC|O_EXCL))
  99     {
 100         case O_EXCL:
 101         case O_EXCL|O_TRUNC:
 102             return -1;
 103     }
 104
 105     if (flags & O_WRITE)    openmode |= FMF_WRITE;
 106     if (flags & O_READ)     openmode |= FMF_READ;
 107     if (flags & O_EXEC)     openmode |= FMF_EXECUTE;
 108     if (flags & O_CREAT)    openmode |= FMF_CREATE;
 109     if (flags & O_NONBLOCK) openmode |= FMF_NONBLOCK;
 110     if (flags & O_APPEND)   openmode |= FMF_APPEND;
 111
 112     return openmode;
 113 }
 114
 115 int __open(int wanted_fd, const char *pathname, int flags, int mode)
 116 {
 117     BPTR fh = BNULL, lock = BNULL;
 118     fdesc *currdesc = NULL;
 119     fcb *cblock = NULL;
 120     struct FileInfoBlock *fib = NULL;
 121     LONG  openmode = __oflags2amode(flags);
 122
 123     if (__doupath && pathname[0] == '\0')
 124     {
 125         /* On *nix "" is not really a valid file name.  */
 126         errno = ENOENT;
 127         return -1;
 128     }
 129
 130     pathname = __path_u2a(pathname);
 131     if (!pathname) return -1;
 132
 133     D(bug("__open: entering, wanted fd = %d, path = %s, flags = %d, mode = %d\n", wanted_fd, pathname, flags, mode));
 134
 135     if (openmode == -1)
 136     {
 137         errno = EINVAL;
 138         D(bug( "__open: exiting with error EINVAL\n"));
 139         return -1;
 140     }
 141
 142     cblock = AllocVec(sizeof(fcb), MEMF_ANY | MEMF_CLEAR);
 143     if (!cblock) { D(bug("__open: no memory [1]\n")); goto err; }
 144     currdesc = __alloc_fdesc();
 145     if (!currdesc) { D(bug("__open: no memory [2]\n")); goto err; }
 146     currdesc->fdflags = 0;
 147     currdesc->fcb = cblock;
 148
 149     wanted_fd = __getfdslot(wanted_fd);
 150     if (wanted_fd == -1) { D(bug("__open: no free fd\n")); goto err; }
 151
 152     lock = Lock((char *)pathname, SHARED_LOCK);
 153     if (!lock)
 154     {
 155         if (IoErr() == ERROR_OBJECT_WRONG_TYPE)
 156         {
 157             /*
 158                Needed for sfs file system which reports this error number on a
 159                Lock aaa/bbb/ccc with bbb being a file instead of a directory.
 160             */
 161             errno = ENOTDIR;
 162             goto err;
 163         }
 164
 165         if
 166         (
 167             (IoErr() != ERROR_OBJECT_NOT_FOUND) ||
 168             /* If the file doesn't exist and the flag O_CREAT is not set return an error */
 169             (IoErr() == ERROR_OBJECT_NOT_FOUND && !(flags & O_CREAT))
 170         )
 171         {
 172             errno = IoErr2errno(IoErr());
 173             goto err;
 174         }
 175     }
 176     else
 177     {
 178         /* If the file exists, but O_EXCL is set, then return an error */
 179         if (flags & O_EXCL)
 180         {
 181             errno = EEXIST;
 182             goto err;
 183         }
 184
 185         fib = AllocDosObject(DOS_FIB, NULL);
 186         if (!fib)
 187         {
 188            errno = IoErr2errno(IoErr());
 189            goto err;
 190         }
 191
 192         if (!Examine(lock, fib))
 193         {
 194             /*
 195                 The filesystem in which the file resides doesn't support
 196                 the EXAMINE action. It might be broken or might also not
 197                 be a filesystem at all. So let's assume the file is not a
 198                 diretory.
 199            */
 200            fib->fib_DirEntryType = 0;
 201         }
 202
 203         /* FIXME: implement softlink handling */
 204
 205         /* Check if it's a directory or a softlink.
 206            Softlinks are not handled yet, though */
 207         if (fib->fib_DirEntryType > 0)
 208         {
 209             /* A directory cannot be opened for writing */
 210             if (openmode & FMF_WRITE)
 211             {
 212                 errno = EISDIR;
 213                 goto err;
 214             }
 215
 216             fh = lock;
 217             FreeDosObject(DOS_FIB, fib);
 218             currdesc->fcb->isdir = 1;
 219
 220             goto success;
 221         }
 222         FreeDosObject(DOS_FIB, fib);
 223         fib = NULL;
 224     }
 225
 226     /* the file exists and it's not a directory or the file doesn't exist */
 227
 228     if (lock)
 229     {
 230         UnLock(lock);
 231         lock = BNULL;
 232     }
 233
 234     if (openmode & (FMF_APPEND | FMF_WRITE))
 235         openmode |= FMF_READ; /* force filesystem ACTION_FINDUPDATE */
 236
 237     if (!(fh = Open ((char *)pathname, openmode)) )
 238     {
 239         ULONG ioerr = IoErr();
 240         D(bug("[clib] Open ioerr=%d\n", ioerr));
 241         errno = IoErr2errno(ioerr);
 242         goto err;
 243     }
 244
 245     if((flags & O_TRUNC) && (flags & (O_RDWR | O_WRONLY)))
 246     {
 247         if(SetFileSize(fh, 0, OFFSET_BEGINNING) != 0)
 248         {
 249             /* Ignore error if FSA_SET_FILE_SIZE is not implemented */
 250             if(IoErr() != ERROR_NOT_IMPLEMENTED)
 251             {
 252                 errno = IoErr2errno(IoErr());
 253                 goto err;
 254             }
 255         }
 256     }
 257
 258 success:
 259     currdesc->fcb->fh        = fh;
 260     currdesc->fcb->flags     = flags;
 261     currdesc->fcb->opencount = 1;
 262
 263     __setfdesc(wanted_fd, currdesc);
 264
 265     D(bug("__open: exiting fd=%d\n", wanted_fd));
 266
 267     return wanted_fd;
 268
 269 err:
 270     if (fib) FreeDosObject(DOS_FIB, fib);
 271     if (cblock) FreeVec(cblock);
 272     if (currdesc) __free_fdesc(currdesc);
 273     if (fh && fh != lock) Close(fh);
 274     if (lock) UnLock(lock);
 275
 276     D(bug("__open: exiting with error %d\n", errno ));
 277
 278     return -1;
 279 }
 280
 281 fdesc *__alloc_fdesc(void)
 282 {
 283     fdesc * desc;
 284
 285     desc = AllocPooled(__fd_mempool, sizeof(fdesc));
 286
 287     D(bug("Allocated fdesc %x from %x pool\n", desc, __fd_mempool));
 288
 289     return desc;
 290 }
 291
 292 void __free_fdesc(fdesc *desc)
 293 {
 294     D(bug("Freeing fdesc %x from %x pool\n", desc, __fd_mempool));
 295     FreePooled(__fd_mempool, desc, sizeof(fdesc));
 296 }
 297
 298
 299 struct __reg_fdarray {
 300     struct MinNode node;
 301     struct Task *task;
 302     fdesc **fdarray;
 303     int numslots;
 304 };
 305
 306 /* Some local variables for register_init_fdarray */
 307 static int __fdinit = 0;
 308 static struct SignalSemaphore __fdsem;
 309 static struct MinList __fdreglist;
 310
 311 int __init_vars(void)
 312 {
 313     InitSemaphore(&__fdsem);
 314     NEWLIST(&__fdreglist);
 315
 316     return TRUE;
 317 }
 318
 319 int __register_init_fdarray(struct arosc_privdata *priv)
 320 {
 321     /* arosc privdata should not be used inside this function,
 322      * this function is called before aroscbase is initialized
 323      */
 324     struct __reg_fdarray *regnode = AllocVec(sizeof(struct __reg_fdarray), MEMF_ANY|MEMF_CLEAR);
 325
 326     if (regnode == NULL)
 327         return 0;
 328
 329     regnode->task = FindTask(NULL);
 330     regnode->fdarray = priv->acpd_fd_array;
 331     regnode->numslots = priv->acpd_numslots;
 332
 333     D(bug("Allocated regnode: %p, fdarray: %p, numslots: %d\n",
 334           regnode, regnode->fdarray, regnode->numslots
 335     ));
 336
 337     ObtainSemaphore(&__fdsem);
 338     AddHead((struct List *)&__fdreglist, (struct Node *)regnode);
 339     ReleaseSemaphore(&__fdsem);
 340
 341     return 1;
 342 }
 343
 344 /* FIXME: perhaps this has to be handled in a different way...  */
 345 int __init_stdfiles(void)
 346 {
 347     struct Process *me;
 348     fcb *infcb = NULL, *outfcb = NULL, *errfcb = NULL;
 349     fdesc *indesc=NULL, *outdesc=NULL, *errdesc=NULL;
 350     int res = __getfdslot(2);
 351
 352     if
 353     (
 354         res == -1                           ||
 355         !(infcb  = AllocVec(sizeof(fcb), MEMF_ANY | MEMF_CLEAR)) ||
 356         !(indesc  = __alloc_fdesc()) ||
 357         !(outfcb = AllocVec(sizeof(fcb), MEMF_ANY | MEMF_CLEAR)) ||
 358         !(outdesc = __alloc_fdesc()) ||
 359         !(errfcb = AllocVec(sizeof(fcb), MEMF_ANY | MEMF_CLEAR)) ||
 360         !(errdesc = __alloc_fdesc())
 361     )
 362     {
 363         if(infcb)
 364             FreeVec(infcb);
 365         if(indesc)
 366             __free_fdesc(indesc);
 367         if(outfcb)
 368             FreeVec(outfcb);
 369         if(outdesc)
 370             __free_fdesc(outdesc);
 371         if(errfcb)
 372             FreeVec(errfcb);
 373         if(errdesc)
 374             __free_fdesc(errdesc);
 375         SetIoErr(ERROR_NO_FREE_STORE);
 376         return 0;
 377     }
 378
 379     indesc->fdflags = 0;
 380     outdesc->fdflags = 0;
 381     errdesc->fdflags = 0;
 382
 383     indesc->fcb = infcb;
 384     outdesc->fcb = outfcb;
 385     errdesc->fcb = errfcb;
 386
 387     me = (struct Process *)FindTask (NULL);
 388     indesc->fcb->fh  = Input();
 389     outdesc->fcb->fh = Output();
 390     errdesc->fcb->fh = me->pr_CES ? me->pr_CES : me->pr_COS;
 391
 392     indesc->fcb->flags  = O_RDONLY;
 393     outdesc->fcb->flags = O_WRONLY | O_APPEND;
 394     errdesc->fcb->flags = O_WRONLY | O_APPEND;
 395
 396     indesc->fcb->opencount = outdesc->fcb->opencount = errdesc->fcb->opencount = 1;
 397     indesc->fcb->privflags = outdesc->fcb->privflags = errdesc->fcb->privflags = _FCB_DONTCLOSE_FH;
 398
 399     __fd_array[STDIN_FILENO]  = indesc;
 400     __fd_array[STDOUT_FILENO] = outdesc;
 401     __fd_array[STDERR_FILENO] = errdesc;
 402
 403     return 1;
 404 }
 405
 406 static int __copy_fdarray(fdesc **__src_fd_array, int numslots)
 407 {
 408     int i;
 409
 410     for(i = numslots - 1; i >= 0; i--)
 411     {
 412         if(__src_fd_array[i])
 413         {
 414             if(__getfdslot(i) != i)
 415                 return 0;
 416
 417             if((__fd_array[i] = __alloc_fdesc()) == NULL)
 418                 return 0;
 419
 420             __fd_array[i]->fdflags = __src_fd_array[i]->fdflags;
 421             __fd_array[i]->fcb = __src_fd_array[i]->fcb;
 422             __fd_array[i]->fcb->opencount++;
 423         }
 424     }
 425
 426     return 1;
 427 }
 428
 429 int __init_fd(void)
 430 {
 431     struct __reg_fdarray *regnodeit, *regnode = NULL;
 432     struct Task *self = FindTask(NULL);
 433
 434     if (!__fdinit)
 435     {
 436         __init_vars();
 437         __fdinit = 1;
 438     }
 439
 440     __fd_mempool = CreatePool(MEMF_PUBLIC, 16*sizeof(fdesc), 16*sizeof(fdesc));
 441
 442     ObtainSemaphore(&__fdsem);
 443     ForeachNode(&__fdreglist, regnodeit)
 444     {
 445         if (regnodeit->task == self)
 446         {
 447             regnode = regnodeit;
 448
 449             D(bug("Found regnode: %p, fdarray: %p, numslots: %d\n",
 450                   regnode, regnode->fdarray, regnode->numslots
 451             ));
 452             Remove((struct Node *)regnode);
 453             break;
 454         }
 455     }
 456     ReleaseSemaphore(&__fdsem);
 457
 458     if (regnode == NULL)
 459         return __init_stdfiles();
 460     else
 461     {
 462         int ok = __copy_fdarray(regnode->fdarray, regnode->numslots);
 463
 464         FreeVec(regnode);
 465
 466         return ok;
 467     }
 468 }
 469
 470 void __exit_fd(void)
 471 {
 472     int i = __numslots;
 473     while (i)
 474     {
 475         if (__fd_array[--i])
 476             close(i);
 477     }
 478     DeletePool(__fd_mempool);
 479 }
 480
 481 #include <stdio.h>
 482
 483 void __updatestdio(void)
 484 {
 485     struct Process *me;
 486
 487     me = (struct Process *)FindTask(NULL);
 488
 489     fflush(stdin);
 490     fflush(stdout);
 491     fflush(stderr);
 492
 493     __fd_array[STDIN_FILENO]->fcb->fh  = Input();
 494     __fd_array[STDOUT_FILENO]->fcb->fh = Output();
 495     __fd_array[STDERR_FILENO]->fcb->fh = me->pr_CES ? me->pr_CES : me->pr_COS;
 496
 497     __fd_array[STDIN_FILENO]->fcb->privflags =
 498         __fd_array[STDOUT_FILENO]->fcb->privflags =
 499         __fd_array[STDERR_FILENO]->fcb->privflags = _FCB_DONTCLOSE_FH;
 500 }
 501
 502 ADD2INIT(__init_fd, 2);
 503 ADD2EXIT(__exit_fd, 2);