workbench/c/Automount.c

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