compiler/clib/__open.c

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