workbench/c/Automount.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id: $
   4 */
   5
   6 #include <aros/debug.h>
   7 #include <dos/dos.h>
   8 #include <dos/rdargs.h>
   9 #include <exec/lists.h>
  10 #include <exec/memory.h>
  11 #include <libraries/expansion.h>
  12 #include <libraries/expansionbase.h>
  13 #include <proto/alib.h>
  14 #include <proto/arossupport.h>
  15 #include <proto/dos.h>
  16 #include <proto/exec.h>
  17 #include <proto/expansion.h>
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 struct HandlerNode
  23 {
  24     struct MinNode n;
  25     ULONG          id;
  26     ULONG          mask;
  27     char           handler[1];
  28 };
  29
  30 struct MinList handlerlist;
  31 APTR pool;
  32
  33 LONG parsePrefs(char *buffer, LONG size)
  34 {
  35     struct CSource csrc = {buffer, size, 0};
  36     char ident[256];
  37     LONG res;
  38     WORD line = 1;
  39
  40     D(bug("[Automount] parsePrefs()\n"));
  41
  42     while (csrc.CS_CurChr < csrc.CS_Length)
  43     {
  44         struct HandlerNode *tn;
  45         int i;
  46         char *p;
  47         ULONG id = 0;
  48         ULONG mask = 0xFFFFFFFF;
  49
  50         DB2(bug("[parsePrefs] Cur %d, Length %d\n", csrc.CS_CurChr, csrc.CS_Length));
  51
  52         res = ReadItem(ident, 256, &csrc);
  53         switch (res)
  54         {
  55         case ITEM_ERROR:
  56             return IoErr();
  57
  58         case ITEM_UNQUOTED:
  59             if (ident[0] == '#')
  60             {
  61                 /* Skip over to the end of line */
  62                 while ((csrc.CS_CurChr < csrc.CS_Length) && (buffer[csrc.CS_CurChr] != '\n'))
  63                     csrc.CS_CurChr++;
  64
  65                 goto next_line;
  66             }
  67             /* Fall through */
  68         case ITEM_QUOTED:
  69             p = ident;
  70             for (i = 0; i < 4; i++)
  71             {
  72                 UBYTE c;
  73
  74                 if (!*p)
  75                 {
  76                     Printf("LINE %ld: Mailformed filesystem ID\n", line);
  77                     return -1;
  78                 }
  79
  80                 c = *p++;
  81                 switch (c)
  82                 {
  83                 case '\\':
  84                     c = strtoul(p, &p, 16);
  85                     break;
  86
  87                 case '?':
  88                     mask &= ~(0xFF000000 >> (i << 3));
  89                     c = 0;
  90                 }
  91
  92                 id <<= 8;
  93                 id |= c;
  94             }
  95             break;
  96
  97         default:
  98             Printf("LINE %ld: Missing filesystem ID\n", line);
  99             return -1;
 100         }
 101
 102         res = ReadItem(ident, 256, &csrc);
 103         if (res == ITEM_ERROR)
 104             return IoErr();
 105
 106         if (res != ITEM_EQUAL)
 107         {
 108             Printf("LINE %ld: Unexpected item after filesystem ID\n", line);
 109             return -1;
 110         }
 111
 112         res = ReadItem(ident, 256, &csrc);
 113         if (res == ITEM_ERROR)
 114             return IoErr();
 115
 116         if ((res != ITEM_QUOTED) && (res != ITEM_UNQUOTED))
 117         {
 118             Printf("LINE %ld: Missing handler name\n", line);
 119             return -1;
 120         }
 121
 122         res = strlen(ident);
 123         tn = AllocPooled(pool, sizeof(struct HandlerNode) + res);
 124         if (tn == NULL)
 125             return ERROR_NO_FREE_STORE;
 126
 127         tn->id   = id;
 128         tn->mask = mask;
 129         CopyMem(ident, tn->handler, res + 1);
 130
 131         AddTail((struct List *)&handlerlist, (struct Node *)tn);
 132
 133 next_line:
 134         /*
 135          * Intentional ReadItem() bug workaround.
 136          * Ungets '\n' every time, causing an infinite loop without this adjustment.
 137          */
 138         if ((csrc.CS_CurChr < csrc.CS_Length) && (buffer[csrc.CS_CurChr] == '\n'))
 139         {
 140             line++;
 141             csrc.CS_CurChr++;
 142         }
 143     }
 144
 145     return 0;
 146 }
 147
 148 static LONG LoadPrefs(STRPTR filename)
 149 {
 150     struct FileInfoBlock fib;
 151     char *buffer;
 152     LONG retval = 0;
 153     LONG size;
 154     BPTR fh;
 155
 156     D(bug("[Automount] LoadPrefs('%s')\n", filename));
 157
 158     fh = Open(filename, MODE_OLDFILE);
 159     if (fh)
 160     {
 161         if (ExamineFH(fh, &fib))
 162         {
 163             if (fib.fib_Size>0)
 164             {
 165                 buffer = AllocMem(fib.fib_Size, MEMF_PUBLIC | MEMF_CLEAR);
 166                 if (buffer)
 167                 {
 168                     size = Read(fh, buffer, fib.fib_Size);
 169                     if (size == fib.fib_Size)
 170                         retval = parsePrefs(buffer, size);
 171                     else
 172                         retval = IoErr();
 173
 174                     FreeMem(buffer, fib.fib_Size);
 175                 }
 176                 else
 177                     retval = ERROR_NO_FREE_STORE;
 178             }
 179         }
 180         else
 181             retval = IoErr();
 182
 183         Close(fh);
 184     }
 185
 186     return retval;
 187 }
 188
 189 static struct HandlerNode *FindHandler(ULONG id)
 190 {
 191     struct HandlerNode *n;
 192
 193     ForeachNode(&handlerlist, n)
 194     {
 195         if (n->id == (id & n->mask))
 196             return n;
 197     }
 198
 199     return NULL;
 200 }
 201
 202 static BOOL IsMounted(struct DeviceNode *dn)
 203 {
 204     BOOL ret = FALSE;
 205     struct DosList *dl = LockDosList(LDF_DEVICES|LDF_READ);
 206
 207     while ((dl = NextDosEntry(dl, LDF_DEVICES)))
 208     {
 209         if (dl == (struct DosList *)dn)
 210         {
 211             ret = TRUE;
 212             break;
 213         }
 214     }
 215
 216     UnLockDosList(LDF_DEVICES|LDF_READ);
 217     return ret;
 218 }
 219
 220 int __nocommandline = 1;
 221
 222 int main(void)
 223 {
 224     LONG res;
 225
 226     pool = CreatePool(1024, 1024, MEMF_ANY);
 227     if (!pool)
 228     {
 229         PrintFault(ERROR_NO_FREE_STORE, "Automount");
 230         return RETURN_FAIL;
 231     }
 232
 233     NewList((struct List *)&handlerlist);
 234     res = LoadPrefs("L:automount-config");
 235
 236     if (res == 0)
 237     {
 238         struct BootNode *n;
 239
 240         ForeachNode(&((struct ExpansionBase *)ExpansionBase)->MountList, n)
 241         {
 242             struct DeviceNode *dn = n->bn_DeviceNode;
 243
 244             D(bug("[Automount] Checking BootNode %b...\n", dn->dn_Name));
 245
 246             if ((!dn->dn_Task) && (!dn->dn_SegList) && (!dn->dn_Handler) && dn->dn_Startup)
 247             {
 248                 struct FileSysStartupMsg *fssm = BADDR(dn->dn_Startup);
 249
 250                 D(bug("[Automount] Not mounted\n"));
 251
 252                 if (fssm->fssm_Environ)
 253                 {
 254                     struct DosEnvec *de = BADDR(fssm->fssm_Environ);
 255
 256                     if (de)
 257                     {
 258                         struct HandlerNode *hn = FindHandler(de->de_DosType);
 259
 260                         if (hn)
 261                         {
 262                             Printf("Mounting %b with %s\n", dn->dn_Name, hn->handler);
 263
 264                             dn->dn_Handler = CreateBSTR(hn->handler);
 265                             if (!dn->dn_Handler)
 266                             {
 267                                 res = ERROR_NO_FREE_STORE;
 268                                 break;
 269                             }
 270
 271                             if (!IsMounted(dn))
 272                             {
 273                                 D(bug("[Automount] Adding DOS entry...\n"));
 274                                 AddDosEntry((struct DosList *)dn);
 275                             }
 276
 277                             if (n->bn_Flags & ADNF_STARTPROC)
 278                             {
 279                                 char *buf;
 280
 281                                 D(bug("[Automount] Starting up...\n"));
 282
 283                                 res = AROS_BSTR_strlen(dn->dn_Name);
 284                                 buf = AllocMem(res + 2, MEMF_ANY);
 285                                 if (!buf)
 286                                 {
 287                                     res = ERROR_NO_FREE_STORE;
 288                                     break;
 289                                 }
 290
 291                                 CopyMem(AROS_BSTR_ADDR(dn->dn_Name), buf, res);
 292                                 buf[res++] = ':';
 293                                 buf[res++] = 0;
 294
 295                                 DeviceProc(buf);
 296                                 FreeMem(buf, res);
 297                             }
 298                         }
 299                     }
 300                 }
 301             }
 302         }
 303     }
 304     else if (res != -1)
 305         PrintFault(res, "Automount");
 306
 307     DeletePool(pool);
 308     return RETURN_OK;
 309 }