compiler/clib/__fdesc.c

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