rom/dos/namefromlock.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Retrieve thew full pathname from a lock.
   6     Lang: english
   7 */
   8 #include <proto/exec.h>
   9 #include <dos/exall.h>
  10 #include <dos/filesystem.h>
  11 #include "dos_intern.h"
  12 #include <aros/debug.h>
  13
  14 struct MyExAllData
  15 {
  16     struct ExAllData ead;
  17     UBYTE            filenamebuffer[MAXFILENAMELENGTH + 1];
  18 };
  19
  20 /*****************************************************************************
  21
  22     NAME */
  23 #include <proto/dos.h>
  24
  25         AROS_LH3(BOOL, NameFromLock,
  26
  27 /*  SYNOPSIS */
  28         AROS_LHA(BPTR,   lock,   D1),
  29         AROS_LHA(STRPTR, buffer, D2),
  30         AROS_LHA(LONG,   length, D3),
  31
  32 /*  LOCATION */
  33         struct DosLibrary *, DOSBase, 67, Dos)
  34
  35 /*  FUNCTION
  36         Get the full path name associated with a lock to a file or
  37         directory into a user supplied buffer.
  38
  39     INPUTS
  40         lock   - Lock to file or directory.
  41         buffer - Buffer to fill. Contains a NUL terminated string if
  42                  all went well.
  43         length - Size of the buffer in bytes.
  44
  45     RESULT
  46         !=0 if all went well, 0 in case of an error. IoErr() will
  47         give additional information in that case.
  48
  49 *****************************************************************************/
  50
  51 /*****************************************************************************
  52
  53     NAME
  54 #include <clib/dos_protos.h>
  55
  56         AROS_LH3(LONG, NameFromFH,
  57
  58     SYNOPSIS
  59         AROS_LHA(BPTR  , fh, D1),
  60         AROS_LHA(STRPTR, buffer, D2),
  61         AROS_LHA(LONG  , len, D3),
  62
  63     LOCATION
  64         struct DosLibrary *, DOSBase, 68, Dos)
  65
  66     FUNCTION
  67         Get the full path name associated with file-handle into a
  68         user supplied buffer.
  69
  70     INPUTS
  71         fh     - File-handle to file or directory.
  72         buffer - Buffer to fill. Contains a NUL terminated string if
  73                  all went well.
  74         length - Size of the buffer in bytes.
  75
  76     RESULT
  77         !=0 if all went well, 0 in case of an error. IoErr() will
  78         give additional information in that case.
  79
  80 *****************************************************************************/
  81 /*AROS alias NameFromFH NameFromLock */
  82 {
  83     AROS_LIBFUNC_INIT
  84
  85     STRPTR               s1, s2, name;
  86     struct Unit         *curlock, *oldlock=NULL;
  87     struct MyExAllData   stackead;
  88     struct ExAllData    *ead = &stackead.ead;
  89     LONG                 error;
  90
  91     /* Get pointer to filehandle */
  92     struct FileHandle   *fh = (struct FileHandle *)BADDR(DupLock(lock));
  93
  94     /* Get pointer to process structure */
  95     struct Process      *me = (struct Process *)FindTask(NULL);
  96
  97     /* Get pointer to I/O request. Use stackspace for now. */
  98     struct IOFileSys     io, *iofs = &io;
  99
 100     if (fh == 0)
 101         return DOSFALSE;
 102
 103     if (length < 1)
 104     {
 105         SetIoErr(ERROR_LINE_TOO_LONG);
 106
 107         return DOSFALSE;
 108     }
 109
 110     /* Prepare I/O request. */
 111     iofs->IOFS.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
 112     iofs->IOFS.io_Message.mn_ReplyPort    = &me->pr_MsgPort;
 113     iofs->IOFS.io_Message.mn_Length       = sizeof(struct IOFileSys);
 114
 115     iofs->IOFS.io_Device = (fh == NULL)
 116                                 ? DOSBase->dl_NulHandler
 117                                 : fh->fh_Device;
 118
 119     /* Construct the name from top to bottom */
 120     name = buffer + length;
 121     *--name = 0;
 122     curlock = fh->fh_Unit;
 123
 124     /* Loop over path */
 125     do
 126     {
 127         /* Read name of current lock (into the user supplied buffer) */
 128         iofs->IOFS.io_Unit                  = curlock;
 129         iofs->IOFS.io_Command               = FSA_EXAMINE;
 130         iofs->io_Union.io_EXAMINE.io_ead    = ead;
 131         iofs->io_Union.io_EXAMINE.io_Size   = sizeof(stackead);
 132         iofs->io_Union.io_EXAMINE.io_Mode   = ED_TYPE;
 133
 134         DosDoIO(&iofs->IOFS);
 135
 136         error = iofs->io_DosError;
 137
 138         /* Move name to the top of the buffer. */
 139         if(!error)
 140         {
 141             s1 = s2 = ead->ed_Name;
 142
 143             while(*s2++)
 144             {
 145                 ;
 146             }
 147
 148             if(ead->ed_Type == ST_ROOT)
 149             {
 150                 if (name > buffer)
 151                 {
 152                     *--name=':';
 153                 }
 154                 else
 155                 {
 156                     error = ERROR_LINE_TOO_LONG;
 157                 }
 158             }
 159             else if(oldlock != NULL)
 160             {
 161                 if (name > buffer)
 162                 {
 163                     *--name = '/';
 164                 }
 165                 else
 166                 {
 167                     error = ERROR_LINE_TOO_LONG;
 168                 }
 169             }
 170
 171             if (!error)
 172             {
 173                         s2--;
 174
 175                         if (name - (s2 - s1) >= buffer)
 176                         {
 177                             while(s2 > s1)
 178                         {
 179                             *--name = *--s2;
 180                         }
 181                         }
 182                         else
 183                         {
 184                             error = ERROR_LINE_TOO_LONG;
 185                         }
 186             }
 187
 188         } /* if(!error) */
 189
 190         /* Read the parent's lock (if there is a parent) */
 191         if(!error && (ead->ed_Type != ST_ROOT))
 192         {
 193             iofs->IOFS.io_Command               = FSA_OPEN;
 194             iofs->io_Union.io_OPEN.io_Filename  = "/";
 195             iofs->io_Union.io_OPEN.io_FileMode  = 0;
 196
 197             DosDoIO(&iofs->IOFS);
 198
 199             curlock = iofs->IOFS.io_Unit;
 200             error = iofs->io_DosError;
 201         }
 202
 203         /* Free the old lock if it was allocated by NameFromLock(). */
 204         if(oldlock != NULL)
 205         {
 206             iofs->IOFS.io_Unit      = oldlock;
 207             iofs->IOFS.io_Command   = FSA_CLOSE;
 208
 209             DosDoIO(&iofs->IOFS);
 210         }
 211
 212         oldlock = curlock;
 213
 214     }
 215     while(!error && (ead->ed_Type != ST_ROOT));
 216
 217     /* Move the name from the top to the bottom of the buffer. */
 218
 219     if (!error)
 220     {
 221         UBYTE c, old_c = '\0';
 222
 223         do
 224         {
 225             c = *name++;
 226
 227             if ((c != '/') || (old_c != ':'))
 228             {
 229                 *buffer++ = c;
 230             }
 231
 232             old_c = c;
 233
 234         }
 235         while (c);
 236     }
 237
 238     UnLock((BPTR)MKBADDR(fh));
 239
 240     /* All done. */
 241
 242     SetIoErr(error);
 243
 244     return error
 245         ? DOSFALSE
 246         : DOSTRUE;
 247
 248     AROS_LIBFUNC_EXIT
 249
 250 } /* NameFromLock */