rom/dos/startnotify.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8 #include <dos/notify.h>
   9 #include <dos/exall.h>
  10 #include <proto/dos.h>
  11 #include "dos_intern.h"
  12 #include <aros/debug.h>
  13 #include <string.h>
  14
  15 /*****************************************************************************
  16
  17     NAME */
  18
  19         AROS_LH1(BOOL, StartNotify,
  20
  21 /*  SYNOPSIS */
  22         AROS_LHA(struct NotifyRequest *, notify, D1),
  23
  24 /*  LOCATION */
  25         struct DosLibrary *, DOSBase, 148, Dos)
  26
  27 /*  FUNCTION
  28
  29     Send a notification request to a filesystem. You will then be notified
  30     whenever the file (or directory) changes.
  31
  32     INPUTS
  33
  34     notify  --  a notification request for the file or directory to monitor
  35
  36     RESULT
  37
  38     Success/failure indicator.
  39
  40     NOTES
  41
  42     The file or directory connected to a notification request does not have
  43     to exist at the time of calling StartNotify().
  44     The NotifyRequest used with this function should not be altered while
  45     active.
  46
  47     EXAMPLE
  48
  49     BUGS
  50
  51     SEE ALSO
  52
  53     EndNotify(), <dos/notify.h>
  54
  55     INTERNALS
  56
  57 *****************************************************************************/
  58 {
  59     AROS_LIBFUNC_INIT
  60
  61     struct IOFileSys iofs;
  62     struct DevProc *dvp;
  63     UBYTE buf[MAXFILENAMELENGTH+1], *buf2, *p;
  64     ULONG len, len2;
  65     BPTR lock = NULL;
  66
  67     /* set up some defaults */
  68     notify->nr_MsgCount = 0;
  69     notify->nr_FullName = NULL;
  70
  71     /* turn the filename into a device and dir lock */
  72     if ((dvp = GetDeviceProc(notify->nr_Name, NULL)) == NULL)
  73         return DOSFALSE;
  74
  75     /* prepare the notify request */
  76     InitIOFS(&iofs, FSA_ADD_NOTIFY, DOSBase);
  77     iofs.io_Union.io_NOTIFY.io_NotificationRequest = notify;
  78     iofs.IOFS.io_Device = (struct Device *) dvp->dvp_Port;
  79
  80     /* remember the handler for EndNotify() (but see the comments there about
  81      * why we don't really use it */
  82     notify->nr_Handler = dvp->dvp_Port;
  83
  84     /* if no lock is returned by GetDeviceProc() (eg if the path is for a
  85      * device or volume root), then get the handler to resolve the name of the
  86      * device root lock */
  87     if (dvp->dvp_Lock == NULL) {
  88         UBYTE name[MAXFILENAMELENGTH+1], *src, *dst;
  89         struct FileInfoBlock *fib;
  90
  91         src = notify->nr_Name;
  92         dst = name;
  93
  94         while (*src != ':')
  95             *dst++ = *src++;
  96
  97         *dst++ = ':';
  98         *dst++ = '\0';
  99
 100         if ((fib = AllocDosObject(DOS_FIB, NULL)) == NULL) {
 101             FreeDeviceProc(dvp);
 102             return DOSFALSE;
 103         }
 104
 105         if((lock = Lock(name, SHARED_LOCK)) == NULL) {
 106             FreeDosObject(DOS_FIB, fib);
 107             FreeDeviceProc(dvp);
 108             return DOSFALSE;
 109         }
 110
 111         if (!Examine(lock, fib)) {
 112             FreeDosObject(DOS_FIB, fib);
 113             FreeDeviceProc(dvp);
 114             return DOSFALSE;
 115         }
 116
 117         /* copy it to our processing buffer */
 118         src = fib->fib_FileName;
 119         dst = buf;
 120
 121         while (*src != '\0')
 122             *dst++ = *src++;
 123
 124         *dst++ = ':';
 125         *dst++ = '\0';
 126
 127         /* use the root lock we just got as the relative lock */
 128         iofs.IOFS.io_Unit = ((struct FileHandle *) BADDR(lock))->fh_Unit;
 129
 130         FreeDosObject(DOS_FIB, fib);
 131     }
 132
 133     /* otherwise we need to expand the name using the lock */
 134     else {
 135         /* get the name */
 136         if (NameFromLock(dvp->dvp_Lock, buf, sizeof(buf)) == DOSFALSE) {
 137             FreeDeviceProc(dvp);
 138             return DOSFALSE;
 139         }
 140
 141         /* use the assign base lock as the relative lock */
 142         iofs.IOFS.io_Unit = ((struct FileHandle *) BADDR(dvp->dvp_Lock))->fh_Unit;
 143     }
 144
 145     len = strlen(buf);
 146
 147     /* if its not some absolute base thing, then add a dir seperator for
 148      * the concat operation below */
 149     if (buf[len-1] != ':') {
 150         buf[len] = '/';
 151         len++;
 152     }
 153
 154     /* look for the ':' following the assign name in the path provided by
 155      * the caller */
 156     p = notify->nr_Name;
 157     while (*p && *p != ':')
 158         p++;
 159
 160     /* if we found it, move past it */
 161     if (*p)
 162         p++;
 163
 164     /* hit the end, so the name is a relative path, and we take all of it */
 165     else
 166         p = notify->nr_Name;
 167
 168     len2 = strlen(p);
 169
 170     if ((buf2 = AllocVec(len + len2 + 1, MEMF_PUBLIC)) == NULL) {
 171         SetIoErr(ERROR_NO_FREE_STORE);
 172
 173         /* cleanup */
 174         if (lock != NULL)
 175             UnLock(lock);
 176         FreeDeviceProc(dvp);
 177
 178         return DOSFALSE;
 179     }
 180
 181     /* concatenate the two bits */
 182     CopyMem(buf, buf2, len);
 183     CopyMem(p, buf2 + len, len2 + 1);
 184
 185     /* thats our expanded name */
 186     notify->nr_FullName = buf2;
 187
 188     /* send the request, with error reporting */
 189     do {
 190         DosDoIO(&iofs.IOFS);
 191     } while (iofs.io_DosError != 0 && ErrorReport(iofs.io_DosError, REPORT_LOCK, 0, dvp->dvp_Port) == DOSFALSE);
 192
 193     SetIoErr(iofs.io_DosError);
 194
 195     /* cleanup */
 196     if (lock != NULL)
 197         UnLock(lock);
 198     FreeDeviceProc(dvp);
 199
 200     /* something broke, clean up */
 201     if (iofs.io_DosError != 0) {
 202         if (notify->nr_FullName != notify->nr_Name)
 203             FreeVec(notify->nr_FullName);
 204         return DOSFALSE;
 205     }
 206
 207     return DOSTRUE;
 208
 209     AROS_LIBFUNC_EXIT
 210 } /* StartNotify */