rom/dos/lock.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Locks a file or directory.
   6     Lang: English
   7 */
   8
   9 #define DLINK(x)
  10
  11 #include <aros/debug.h>
  12 #include <proto/exec.h>
  13 #include <utility/tagitem.h>
  14 #include <dos/dosextens.h>
  15 #include <proto/dos.h>
  16 #include <proto/utility.h>
  17
  18 #include "dos_intern.h"
  19 #include "fs_driver.h"
  20
  21 static LONG InternalLock(CONST_STRPTR name, LONG accessMode,
  22     BPTR *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, Lock,
  32
  33 /*  SYNOPSIS */
  34         AROS_LHA(CONST_STRPTR, name,       D1),
  35         AROS_LHA(LONG,         accessMode, D2),
  36
  37 /*  LOCATION */
  38         struct DosLibrary *, DOSBase, 14, Dos)
  39
  40 /*  FUNCTION
  41         Gets a lock on a file or directory. There may be more than one
  42         shared lock on a file but only one if it is an exclusive one.
  43         Locked files or directories may not be deleted.
  44
  45     INPUTS
  46         name       - NUL terminated name of the file or directory.
  47         accessMode - One of SHARED_LOCK
  48                             EXCLUSIVE_LOCK
  49
  50     RESULT
  51         Handle to the file or directory or 0 if the object couldn't be locked.
  52         IoErr() gives additional information in that case.
  53
  54     NOTES
  55         The lock structure returned by this function is different
  56         from that of AmigaOS (in fact it is identical to a filehandle).
  57         Do not try to read any internal fields.
  58
  59 *****************************************************************************/
  60
  61 {
  62     AROS_LIBFUNC_INIT
  63
  64     BPTR fl;
  65
  66     /* Sanity check */
  67     if (name == NULL)
  68         return BNULL;
  69
  70     ASSERT_VALID_PTR(name);
  71
  72     D(bug("[Lock] '%s':%d\n", name, accessMode));
  73
  74     if (InternalLock(name, accessMode, &fl, MAX_SOFT_LINK_NESTING, DOSBase))
  75     {
  76         D(bug("[Lock] returned 0x%p\n", fl));
  77         return fl;
  78     }
  79
  80     D(bug("[Lock] failed, err=%d\n", IoErr()));
  81     return BNULL;
  82
  83     AROS_LIBFUNC_EXIT
  84 } /* Lock */
  85
  86
  87 /* Attempt to create a synthetic IN:, OUT:, ERR:,
  88  * STDIN:, STDOUT, or STDERR: lock
  89  */
  90 BOOL pseudoLock(CONST_STRPTR name, LONG lockMode, BPTR *lock, LONG *ret, struct DosLibrary *DOSBase)
  91 {
  92     struct Process *me = (struct Process *)FindTask(NULL);
  93     BPTR fh = (BPTR)-1;
  94
  95     ASSERT_VALID_PROCESS(me);
  96
  97     /* IN:, STDIN: */
  98     if (!Stricmp(name, "IN:") || !Stricmp(name, "STDIN:")) {
  99         if (lockMode != ACCESS_READ) {
 100             SetIoErr(ERROR_OBJECT_IN_USE);
 101             *ret = DOSFALSE;
 102             return TRUE;
 103         }
 104
 105         fh = me->pr_CIS;
 106     }
 107
 108     /* OUT:, STDOUT: */
 109     if (!Stricmp(name, "OUT:") || !Stricmp(name, "STDOUT:")) {
 110         if (lockMode != ACCESS_WRITE) {
 111             SetIoErr(ERROR_OBJECT_IN_USE);
 112             *ret = DOSFALSE;
 113             return TRUE;
 114         }
 115
 116         fh = me->pr_COS;
 117     }
 118
 119
 120     /* ERR:, STDERR: */
 121     if (!Stricmp(name, "ERR:") || !Stricmp(name, "STDERR:")) {
 122         if (lockMode != ACCESS_WRITE) {
 123             SetIoErr(ERROR_OBJECT_IN_USE);
 124             *ret = DOSFALSE;
 125             return TRUE;
 126         }
 127
 128         fh = me->pr_CES;
 129     }
 130
 131     if (fh == (BPTR)-1)
 132         return FALSE;
 133
 134     if (fh == BNULL) {
 135         SetIoErr(ERROR_OBJECT_NOT_FOUND);
 136         *ret = DOSFALSE;
 137         return TRUE;
 138     }
 139
 140     *lock = DupLockFromFH(fh);
 141     if (*lock) {
 142         struct FileLock *fl = BADDR(*lock);
 143         fl->fl_Access = lockMode;
 144     }
 145     *ret = (*lock != BNULL) ? DOSTRUE : DOSFALSE;
 146     return TRUE;
 147 }
 148
 149
 150 /* Try to lock name recursively calling itself in case it's a soft link.
 151    Store result in handle. Return boolean value indicating result. */
 152 static LONG InternalLock(CONST_STRPTR name, LONG accessMode,
 153     BPTR *handle, LONG soft_nesting, struct DosLibrary *DOSBase)
 154 {
 155     /* Get pointer to process structure */
 156     struct Process *me = (struct Process *)FindTask(NULL);
 157     BPTR cur = BNULL;
 158     struct DevProc *dvp = NULL;
 159     LONG ret = DOSFALSE;
 160     LONG error = 0;
 161     STRPTR filename;
 162
 163     ASSERT_VALID_PROCESS(me);
 164     D(bug("[Lock] Process: 0x%p \"%s\", Window: 0x%p, Name: \"%s\", \n", me, me->pr_Task.tc_Node.ln_Name, me->pr_WindowPtr, name));
 165
 166     if(soft_nesting == 0)
 167     {
 168         SetIoErr(ERROR_TOO_MANY_LEVELS);
 169         return DOSFALSE;
 170     }
 171
 172     /* Check for a pseudo-file lock
 173      * (ie IN:, STDOUT:, ERR:, etc)
 174      */
 175     if (pseudoLock(name, accessMode, handle, &ret, DOSBase))
 176         return ret;
 177
 178     filename = strchr(name, ':');
 179     if (!filename)
 180     {
 181         struct MsgPort *port;
 182         BPTR lock;
 183
 184         /* No ':' in the pathname, path is relative to current directory */
 185         cur = me->pr_CurrentDir;
 186         if (cur && cur != (BPTR)-1) {
 187             port = ((struct FileLock *)BADDR(cur))->fl_Task;
 188             lock = cur;
 189         } else {
 190             port = DOSBase->dl_Root->rn_BootProc;
 191             lock = BNULL;
 192         }
 193
 194         error = fs_LocateObject(handle, port, lock, name, accessMode, DOSBase);
 195         SetIoErr(error);
 196     }
 197     else
 198     {
 199         filename++;
 200         do
 201         {
 202             if ((dvp = GetDeviceProc(name, dvp)) == NULL)
 203             {
 204                 error = IoErr();
 205                 break;
 206             }
 207
 208             error = fs_LocateObject(handle, dvp->dvp_Port, dvp->dvp_Lock, filename, accessMode, DOSBase);
 209
 210         } while (error == ERROR_OBJECT_NOT_FOUND);
 211
 212         if (error == ERROR_NO_MORE_ENTRIES)
 213             error = me->pr_Result2 = ERROR_OBJECT_NOT_FOUND;
 214
 215 #ifndef __mc68000
 216         /* FIXME: On Linux hosted we sometimes get ERROR_IS_SOFTLINK with dvp == NULL,
 217          * which causes segfaults below if we don't change "error". Adding !dvp below
 218          * is probably a hack.
 219          *
 220          * This is wrong, GetDeviceProc() can return other errors than ERROR_OBJECT_NOT_FOUND.
 221          */
 222         if (!dvp)
 223             error = me->pr_Result2 = ERROR_OBJECT_NOT_FOUND;
 224 #endif
 225     }
 226
 227     if (error == ERROR_IS_SOFT_LINK)
 228     {
 229         STRPTR softname = ResolveSoftlink(cur, dvp, name, DOSBase);
 230
 231         if (softname)
 232         {
 233             BPTR olddir = BNULL;
 234
 235             /*
 236              * ResolveSoftlink() gives us path relative to either 'cur' lock
 237              * (if on current volume), or 'dvp' volume root (if on different volume).
 238              * In the latter case we need to change current directory to volume's root
 239              * in order to follow the link correctly.
 240              */
 241             if (dvp)
 242             {
 243                 olddir = me->pr_CurrentDir;
 244                 error = RootDir(dvp, DOSBase);
 245             }
 246             else
 247                 error = 0;
 248
 249             if (!error)
 250             {
 251                 ret = InternalLock(softname, accessMode, handle, soft_nesting - 1, DOSBase);
 252                 error = ret ? 0 : IoErr();
 253                 D(bug("[Lock] Resolve error %d\n", error));
 254
 255                 if (olddir)
 256                     UnLock(CurrentDir(olddir));
 257             }
 258
 259             FreeVec(softname);
 260         }
 261         else
 262             error = IoErr();
 263     }
 264
 265     FreeDeviceProc(dvp);
 266
 267     if (error)
 268     {
 269         SetIoErr(error);
 270         ret = DOSFALSE;
 271     }
 272     else
 273         ret = DOSTRUE;
 274
 275     return ret;
 276 }
 277
 278 /*
 279  * Resolve a softlink.
 280  * Returns AllocVec()ed buffer with softlink contents.
 281  */
 282 STRPTR ResolveSoftlink(BPTR cur, struct DevProc *dvp, CONST_STRPTR name, struct DosLibrary *DOSBase)
 283 {
 284     ULONG buffer_size = 256;
 285     STRPTR softname;
 286     LONG continue_loop;
 287     LONG written;
 288
 289     DLINK(bug("[Softlink] Resolving softlink %s...\n", name));
 290
 291     do
 292     {
 293         continue_loop = FALSE;
 294
 295         if (!(softname = AllocVec(buffer_size, MEMF_PUBLIC|MEMF_CLEAR)))
 296         {
 297             SetIoErr(ERROR_NO_FREE_STORE);
 298             break;
 299         }
 300
 301         written = fs_ReadLink(cur, dvp, name, softname, buffer_size, DOSBase);
 302
 303         switch (written)
 304         {
 305         case -1:
 306             /* An error occured */
 307             DLINK(bug("[Softlink] Error %d reading softlink\n", IoErr()));
 308             break;
 309
 310         case -2:
 311             /* If there's not enough space in the buffer, increase it and try again */
 312             continue_loop = TRUE;
 313             buffer_size <<= 1;
 314
 315             DLINK(bug("[Softlink] Increased buffer size up to %u\n", buffer_size));
 316             break;
 317
 318         default:
 319             /* All OK */
 320             DLINK(bug("[Softlink] Resolved path: %s\n", softname));
 321             return softname;
 322         }
 323
 324         FreeVec(softname);
 325     }
 326     while(continue_loop);
 327
 328     return NULL;
 329 }
 330
 331 /* Change to root directory of the specified device */
 332 LONG RootDir(struct DevProc *dvp, struct DosLibrary *DOSBase)
 333 {
 334     BPTR lock = BNULL;
 335     LONG error;
 336
 337     /* We already have a DeviceProc structure, so just use internal routine. */
 338     error = fs_LocateObject(&lock, dvp->dvp_Port, dvp->dvp_Lock, "", SHARED_LOCK, DOSBase);
 339
 340     if (!error)
 341         CurrentDir(lock);
 342
 343     return error;
 344 }