rom/dos/lock.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Locks a file or directory.
   6     Lang: English
   7 */
   8
   9 #include <proto/exec.h>
  10 #include <utility/tagitem.h>
  11 #include <dos/dosextens.h>
  12 #include <dos/filesystem.h>
  13 #include <proto/dos.h>
  14 #include <proto/utility.h>
  15 #include "dos_intern.h"
  16
  17 #define  DEBUG  0
  18 #include <aros/debug.h>
  19
  20 LONG InternalLock(CONST_STRPTR name, LONG accessMode,
  21     struct FileHandle *handle, LONG soft_nesting, struct DosLibrary *DOSBase);
  22
  23 #define MAX_SOFT_LINK_NESTING 16 /* Maximum level of soft links nesting */
  24
  25 /*****************************************************************************
  26
  27     NAME */
  28 #include <proto/dos.h>
  29
  30         AROS_LH2(BPTR, Lock,
  31
  32 /*  SYNOPSIS */
  33         AROS_LHA(CONST_STRPTR, name,       D1),
  34         AROS_LHA(LONG,         accessMode, D2),
  35
  36 /*  LOCATION */
  37         struct DosLibrary *, DOSBase, 14, Dos)
  38
  39 /*  FUNCTION
  40         Gets a lock on a file or directory. There may be more than one
  41         shared lock on a file but only one if it is an exclusive one.
  42         Locked files or directories may not be deleted.
  43
  44     INPUTS
  45         name       - NUL terminated name of the file or directory.
  46         accessMode - One of SHARED_LOCK
  47                             EXCLUSIVE_LOCK
  48
  49     RESULT
  50         Handle to the file or directory or 0 if the object couldn't be locked.
  51         IoErr() gives additional information in that case.
  52
  53     NOTES
  54         The lock structure returned by this function is different
  55         from that of AmigaOS (in fact it is identical to a filehandle).
  56         Do not try to read any internal fields.
  57
  58 *****************************************************************************/
  59
  60 {
  61     AROS_LIBFUNC_INIT
  62
  63     LONG error;
  64
  65     ASSERT_VALID_PTR(name);
  66
  67     /* Sanity check */
  68     if (name == NULL)
  69         return NULL;
  70
  71     /* Create filehandle */
  72     struct FileHandle *ret = (struct FileHandle *)AllocDosObject(DOS_FILEHANDLE, NULL);
  73
  74     if (ret != NULL)
  75     {
  76         if(InternalLock(name, accessMode, ret, MAX_SOFT_LINK_NESTING, DOSBase))
  77         {
  78             return MKBADDR(ret);
  79         }
  80         else
  81         {
  82             error = IoErr();
  83             FreeDosObject(DOS_FILEHANDLE, ret);
  84         }
  85     }
  86     else
  87     {
  88         error = ERROR_NO_FREE_STORE;
  89     }
  90
  91     SetIoErr(error);
  92     return NULL;
  93
  94     AROS_LIBFUNC_EXIT
  95 } /* Lock */
  96
  97 /* Try to lock name recursively calling itself in case it's a soft link.
  98    Store result in handle. Return boolean value indicating result. */
  99 LONG InternalLock(CONST_STRPTR name, LONG accessMode,
 100     struct FileHandle *handle, LONG soft_nesting, struct DosLibrary *DOSBase)
 101 {
 102     /* Get pointer to I/O request. Use stackspace for now. */
 103     struct IOFileSys iofs;
 104     /* Get pointer to process structure */
 105     struct Process *me = (struct Process *)FindTask(NULL);
 106     struct DevProc *dvp;
 107     LONG ret = DOSFALSE;
 108     LONG error = 0;
 109     LONG error2 = 0;
 110
 111     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));
 112
 113     if(soft_nesting == 0)
 114     {
 115         SetIoErr(ERROR_TOO_MANY_LEVELS);
 116         return DOSFALSE;
 117     }
 118
 119     /* Prepare I/O request. */
 120     InitIOFS(&iofs, FSA_OPEN, DOSBase);
 121
 122     switch (accessMode)
 123     {
 124         case EXCLUSIVE_LOCK:
 125             iofs.io_Union.io_OPEN.io_FileMode = FMF_LOCK | FMF_READ;
 126             break;
 127
 128         case SHARED_LOCK:
 129             iofs.io_Union.io_OPEN.io_FileMode = FMF_READ;
 130             break;
 131
 132         default:
 133             D(bug("[Lock] incompatible mode %d\n", accessMode));
 134             SetIoErr(ERROR_ACTION_NOT_KNOWN);
 135             return DOSFALSE;
 136     }
 137
 138     /* catch the zero-length special case. we can't (currently) call
 139      * GetDeviceProc(), as it will call NameFromLock(), which will
 140      * DupLock(), which will end up here */
 141     if (*name == '\0') {
 142         BPTR cur;
 143         struct FileHandle *fh;
 144
 145         cur = me->pr_CurrentDir;
 146         if (!cur)
 147             cur = DOSBase->dl_SYSLock;
 148
 149         if (cur)
 150         {
 151             fh = BADDR(cur);
 152
 153             iofs.io_Union.io_OPEN.io_Filename = (STRPTR) "";
 154
 155             iofs.IOFS.io_Device = fh->fh_Device;
 156             iofs.IOFS.io_Unit = fh->fh_Unit;
 157
 158             DosDoIO(&iofs.IOFS);
 159
 160             error = me->pr_Result2 = iofs.io_DosError;
 161         }
 162         else
 163         {
 164             error = ERROR_OBJECT_NOT_FOUND;
 165             SetIoErr(error);
 166         }
 167     }
 168     else
 169     {
 170         iofs.io_Union.io_OPEN.io_Filename = StripVolume(name);
 171         dvp = NULL;
 172
 173         do
 174         {
 175             if ((dvp = GetDeviceProc(name, dvp)) == NULL)
 176             {
 177                 error = IoErr();
 178                 break;
 179             }
 180
 181             error = DoIOFS(&iofs, dvp, NULL, DOSBase);
 182         } while (error == ERROR_OBJECT_NOT_FOUND);
 183
 184         if (error == ERROR_NO_MORE_ENTRIES)
 185             error = me->pr_Result2 = ERROR_OBJECT_NOT_FOUND;
 186
 187         if(error == ERROR_IS_SOFT_LINK)
 188         {
 189             ULONG buffer_size = 256;
 190             STRPTR softname;
 191             LONG continue_loop;
 192             LONG written;
 193
 194             do
 195             {
 196                 continue_loop = FALSE;
 197                 if(!(softname = AllocVec(buffer_size, MEMF_PUBLIC)))
 198                 {
 199                     error2 = ERROR_NO_FREE_STORE;
 200                     break;
 201                 }
 202
 203                 written = ReadLink(dvp->dvp_Port, dvp->dvp_Lock, name, softname, buffer_size);
 204                 if(written == -1)
 205                 {
 206                     /* An error occured */
 207                     error2 = IoErr();
 208                 }
 209                 else if(written == -2)
 210                 {
 211                     /* If there's not enough space in the buffer, increase
 212                        it and try again */
 213                     continue_loop = TRUE;
 214                     buffer_size *= 2;
 215                 }
 216                 else if(written >= 0)
 217                 {
 218                     /* All OK */
 219                     BPTR olddir;
 220                     olddir = CurrentDir(dvp->dvp_Lock);
 221                     ret = InternalLock(softname, accessMode, handle, soft_nesting - 1, DOSBase);
 222                     error2 = IoErr();
 223                     CurrentDir(olddir);
 224                 }
 225                 else
 226                     error2 = ERROR_UNKNOWN;
 227
 228                 FreeVec(softname);
 229             }
 230             while(continue_loop);
 231         }
 232
 233         FreeDeviceProc(dvp);
 234     }
 235
 236     if(!error)
 237     {
 238         handle->fh_Device = iofs.IOFS.io_Device;
 239         handle->fh_Unit   = iofs.IOFS.io_Unit;
 240         return DOSTRUE;
 241     }
 242     else if(error == ERROR_IS_SOFT_LINK)
 243     {
 244         if(!ret)
 245             SetIoErr(error2);
 246         else
 247             SetIoErr(0);
 248         return ret;
 249     }
 250     else
 251     {
 252         SetIoErr(error);
 253         return DOSFALSE;
 254     }
 255 }