rom/dos/open.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Open a file with the specified mode.
   6     Lang: english
   7 */
   8
   9 #include <aros/debug.h>
  10 #include <exec/memory.h>
  11 #include <exec/lists.h>
  12 #include <proto/exec.h>
  13 #include <utility/tagitem.h>
  14 #include <dos/dosextens.h>
  15 #include <dos/stdio.h>
  16 #include <proto/dos.h>
  17 #include <proto/utility.h>
  18
  19 #include "dos_intern.h"
  20
  21 static LONG InternalOpen(CONST_STRPTR name, LONG accessMode,
  22     struct FileHandle *handle, LONG soft_nesting, struct DosLibrary *DOSBase);
  23
  24 #define MAX_SOFT_LINK_NESTING 16 /* Maximum level of soft links nesting */
  25
  26 /*****************************************************************************
  27
  28     NAME */
  29 #include <proto/dos.h>
  30
  31         AROS_LH2(BPTR, Open,
  32
  33 /*  SYNOPSIS */
  34         AROS_LHA(CONST_STRPTR, name,       D1),
  35         AROS_LHA(LONG,         accessMode, D2),
  36
  37 /*  LOCATION */
  38         struct DosLibrary *, DOSBase, 5, Dos)
  39
  40 /*  FUNCTION
  41         Opens a file for read and/or write depending on the accessmode given.
  42
  43     INPUTS
  44         name       - NUL terminated name of the file.
  45         accessMode - One of MODE_OLDFILE   - open existing file
  46                             MODE_NEWFILE   - delete old, create new file
  47                                              exclusive lock
  48                             MODE_READWRITE - open new one if it doesn't exist
  49
  50     RESULT
  51         Handle to the file or 0 if the file couldn't be opened.
  52         IoErr() gives additional information in that case.
  53
  54     NOTES
  55
  56     EXAMPLE
  57
  58     BUGS
  59
  60     SEE ALSO
  61
  62     INTERNALS
  63
  64 *****************************************************************************/
  65 {
  66     AROS_LIBFUNC_INIT
  67
  68     struct FileHandle *ret;
  69     LONG error;
  70
  71     /* Sanity check */
  72     if (name == NULL) return BNULL;
  73
  74     /* Create filehandle */
  75     ret = (struct FileHandle *)AllocDosObject(DOS_FILEHANDLE,NULL);
  76
  77     if (ret != NULL)
  78     {
  79         LONG ok = InternalOpen(name, accessMode, ret, MAX_SOFT_LINK_NESTING, DOSBase);
  80         D(bug("[Open] = %p, Error = %d\n", ok ? MKBADDR(ret) : BNULL, IoErr()));
  81         if (ok)
  82         {
  83             return MKBADDR(ret);
  84         }
  85         else
  86         {
  87             error = IoErr();
  88             FreeDosObject(DOS_FILEHANDLE,ret);
  89         }
  90     }
  91     else
  92         error = ERROR_NO_FREE_STORE;
  93
  94     SetIoErr(error);
  95     return BNULL;
  96
  97     AROS_LIBFUNC_EXIT
  98 } /* Open */
  99
 100
 101 static LONG dupHandle(struct FileHandle *fh, BPTR lock, struct DosLibrary *DOSBase)
 102 {
 103     LONG err;
 104     struct MsgPort *port;
 105     struct FileLock *fl;
 106
 107     if (lock == BNULL)
 108         return DOSFALSE;
 109
 110     fl = BADDR(lock);
 111     port = fl->fl_Task;
 112
 113     err = dopacket2(DOSBase, NULL, port, ACTION_FH_FROM_LOCK, MKBADDR(fh), lock);
 114
 115     if (err != DOSFALSE) {
 116         fh->fh_Type = port;
 117         if (fh->fh_Interactive)
 118             SetVBuf(MKBADDR(fh), NULL, BUF_LINE, -1);
 119         else
 120             SetVBuf(MKBADDR(fh), NULL, BUF_NONE, -1);
 121     }
 122
 123     return err;
 124 }
 125
 126
 127 /* Try to open name recursively calling itself in case it's a soft link.
 128    Store result in handle. Return boolean value indicating result. */
 129 static LONG InternalOpen(CONST_STRPTR name, LONG accessMode,
 130     struct FileHandle *handle, LONG soft_nesting, struct DosLibrary *DOSBase)
 131 {
 132     /* Get pointer to process structure */
 133     struct Process *me = (struct Process *)FindTask(NULL);
 134     LONG ret = DOSFALSE;
 135     LONG error = 0;
 136     BPTR con, ast;
 137
 138     ASSERT_VALID_PROCESS(me);
 139
 140     D(bug("[Open] %s: 0x%p \"%s\", Name: \"%s\" File: %p\n",
 141           __is_process(me) ? "Process" : "Task", me, me->pr_Task.tc_Node.ln_Name,
 142           name, MKBADDR(handle)));
 143
 144     if(soft_nesting == 0)
 145     {
 146         SetIoErr(ERROR_TOO_MANY_LEVELS);
 147         return DOSFALSE;
 148     }
 149
 150     /* IN:, OUT:, ERR: pseudodevices
 151      */
 152     if (pseudoLock(name, (accessMode == MODE_OLDFILE) ? ACCESS_READ :
 153                          ((accessMode == MODE_NEWFILE) ? ACCESS_WRITE : 0),
 154                          &ast, &ret, DOSBase)) {
 155         return dupHandle(handle, ast, DOSBase);
 156     }
 157
 158     switch(accessMode)
 159     {
 160         case MODE_NEWFILE:
 161         case MODE_READWRITE:
 162             con = me->pr_COS;
 163             ast = me->pr_CES ? me->pr_CES : me->pr_COS;
 164
 165             break;
 166
 167         case MODE_OLDFILE:
 168             ast = con = me->pr_CIS;
 169             break;
 170
 171         default:
 172             SetIoErr(ERROR_NOT_IMPLEMENTED);
 173             return DOSFALSE;
 174     }
 175
 176     if (!Stricmp(name, "CONSOLE:"))
 177         error = fs_Open(handle, me->pr_ConsoleTask, con, accessMode, name, DOSBase);
 178     else if (!Stricmp(name, "*"))
 179         error = fs_Open(handle, me->pr_ConsoleTask, ast, accessMode, name, DOSBase);
 180     else if (!Stricmp(name, "NIL:"))
 181     {
 182         error = fs_Open(handle, BNULL, BNULL, accessMode, name, DOSBase);
 183         SetIoErr(0);
 184     }
 185     else
 186     {
 187         BPTR cur = BNULL;
 188         struct DevProc *dvp = NULL;
 189         STRPTR filename = strchr(name, ':');
 190
 191         if (!filename)
 192         {
 193             struct MsgPort *port;
 194
 195             /* No ':', pathname relative to current dir */
 196             cur = me->pr_CurrentDir;
 197
 198             if (cur && cur != (BPTR)-1) {
 199                 port = ((struct FileLock *)BADDR(cur))->fl_Task;
 200             } else {
 201                 port = DOSBase->dl_Root->rn_BootProc;
 202                 cur = BNULL;
 203             }
 204
 205             error = fs_Open(handle, port, cur, accessMode, name, DOSBase);
 206         }
 207         else
 208         {
 209             filename++;
 210             do
 211             {
 212                 if ((dvp = GetDeviceProc(name, dvp)) == NULL)
 213                 {
 214                     error = IoErr();
 215                     break;
 216                 }
 217
 218                 error = fs_Open(handle, dvp->dvp_Port, dvp->dvp_Lock, accessMode, filename, DOSBase);
 219             } while(error == ERROR_OBJECT_NOT_FOUND && accessMode != MODE_NEWFILE);
 220
 221             if (error == ERROR_NO_MORE_ENTRIES)
 222                 error = ERROR_OBJECT_NOT_FOUND;
 223         }
 224
 225         if (error == ERROR_IS_SOFT_LINK)
 226         {
 227             STRPTR softname = ResolveSoftlink(cur, dvp, name, DOSBase);
 228
 229             if (softname)
 230             {
 231                 /* All OK */
 232                 BPTR olddir = BNULL;
 233
 234                 if (dvp)
 235                 {
 236                     olddir = me->pr_CurrentDir;
 237                     error = RootDir(dvp, DOSBase);
 238                 }
 239                 else
 240                     error = 0;
 241
 242                 if (!error)
 243                 {
 244                     ret = InternalOpen(softname, accessMode, handle, soft_nesting - 1, DOSBase);
 245                     error = ret ? 0 : IoErr();
 246
 247                     if (olddir)
 248                         UnLock(CurrentDir(olddir));
 249                 }
 250
 251                 FreeVec(softname);
 252             }
 253             else
 254                 error = IoErr();
 255         }
 256
 257         FreeDeviceProc(dvp);
 258     }
 259
 260     if (!error)
 261     {
 262         if (IsInteractive(MKBADDR(handle)))
 263             SetVBuf(MKBADDR(handle), NULL, BUF_LINE, -1);
 264
 265         return DOSTRUE;
 266     }
 267     else
 268     {
 269         SetIoErr(error);
 270         return DOSFALSE;
 271     }
 272 }