workbench/c/Mount.c

   1 /*
   2     (C) 1995-2008 The AROS Development Team
   3     (C) 2002-2005 Harry Sintonen
   4     (C) 2005-2007 Pavel Fedin
   5     $Id$
   6
   7     Desc: Mount CLI command
   8     Lang: English
   9 */
  10
  11 /******************************************************************************
  12
  13     NAME
  14
  15         Mount
  16
  17     FORMAT
  18
  19         Mount <Device> <From>
  20
  21     SYNOPSIS
  22
  23         DEVICE/M, FROM/K
  24
  25     LOCATION
  26
  27         Sys:C
  28
  29     FUNCTION
  30
  31         Loads and mounts a device
  32
  33     INPUTS
  34
  35         DEVICE -- The device type to be mounted
  36         FROM   -- Search device in this mountlist
  37
  38     RESULT
  39
  40         Standard DOS error codes.
  41
  42     NOTES
  43
  44     EXAMPLE
  45
  46         Mount DEVS:FAT0
  47         (Mounts a FAT device defined in the DEVS:FAT0 file)
  48
  49     BUGS
  50
  51     SEE ALSO
  52
  53     INTERNALS
  54
  55     HISTORY
  56
  57 ******************************************************************************/
  58
  59 #include <exec/devices.h>
  60 #include <exec/io.h>
  61 #include <exec/memory.h>
  62 #include <exec/semaphores.h>
  63 #include <exec/types.h>
  64 #include <dos/dosextens.h>
  65 #include <dos/exall.h>
  66 #include <dos/filehandler.h>
  67 #include <dos/rdargs.h>
  68 #include <libraries/configvars.h>
  69 #include <libraries/expansion.h>
  70 #include <workbench/workbench.h>
  71 #include <workbench/startup.h>
  72
  73 #include <proto/exec.h>
  74 #include <proto/dos.h>
  75 #include <proto/intuition.h>
  76 #include <proto/utility.h>
  77 #include <proto/icon.h>
  78 #include <proto/expansion.h>
  79
  80 #ifndef __SASC
  81 #ifdef __AROS__
  82 #include <clib/arossupport_protos.h>
  83 #else
  84 #include <clib/debug_protos.h>
  85 #endif
  86 #else
  87 typedef unsigned long IPTR;
  88 #endif
  89
  90 #include <resources/filesysres.h>
  91 #include <string.h>
  92 #include <stdlib.h>
  93 #include <stdio.h>
  94
  95 #define DEBUG_PATCHDOSNODE(x)
  96 #define DEBUG_MOUNT(x)
  97 #define DEBUG_MAKEDOSNODE(x)
  98 #define DEBUG_CHECK(x)
  99
 100 #define MOUNTLIST      "DEVS:MountList"
 101 #define DOSDRIVERS     "DEVS:DOSDrivers/"
 102 #define STORAGEDRIVERS "SYS:Storage/DOSDrivers/"
 103 #define PARAMSLENGTH   (sizeof(struct DosEnvec) + sizeof(IPTR)*4)
 104
 105 enum
 106 {
 107         ERR_SPECIAL = 5000,
 108         ERR_DEVICENOTFOUND,
 109         ERR_INVALIDKEYWORD
 110 };
 111
 112 const char *SearchTable[]=
 113 {
 114         "",
 115         "DEVS:DOSDrivers/",
 116 #ifdef __MORPHOS__
 117         "MOSSYS:DEVS/DOSDrivers/",
 118 #endif
 119         "SYS:Storage/DOSDrivers/",
 120 #ifdef __MORPHOS__
 121         "MOSSYS:Storage/DOSDrivers/",
 122 #endif
 123         NULL
 124 };
 125
 126 /*
 127  * startup,control need to be handled differently.
 128  */
 129
 130 enum
 131 {
 132         ARG_HANDLER,
 133         ARG_EHANDLER,
 134         ARG_FILESYSTEM,
 135         ARG_DEVICE,
 136         ARG_UNIT,
 137         ARG_FLAGS,
 138         ARG_BLOCKSIZE,
 139         ARG_SURFACES,
 140         ARG_BLOCKSPERTRACK,
 141         ARG_SECTORSPERBLOCK,
 142         ARG_RESERVED,
 143         ARG_PREALLOC,
 144         ARG_INTERLEAVE,
 145         ARG_LOWCYL,
 146         ARG_HIGHCYL,
 147         ARG_BUFFERS,
 148         ARG_BUFMEMTYPE,
 149         ARG_MAXTRANSFER,
 150         ARG_MASK,
 151         ARG_BOOTPRI,
 152         ARG_DOSTYPE,
 153         ARG_BAUD,
 154         ARG_CONTROL,
 155         ARG_STACKSIZE,
 156         ARG_PRIORITY,
 157         ARG_GLOBVEC,
 158         ARG_STARTUP,
 159         ARG_ACTIVATE,
 160         ARG_FORCELOAD,
 161         NUM_ARGS
 162 };
 163
 164 const UBYTE options[]=
 165         "HANDLER/K,"
 166         "EHANDLER/K,"
 167         "FILESYSTEM/K,"
 168         "DEVICE/K,"
 169         "UNIT/K,"
 170         "FLAGS/K,"
 171         "SECTORSIZE=BLOCKSIZE/K,"
 172         "SURFACES/K,"
 173         "SECTORSPERTRACK=BLOCKSPERTRACK/K,"
 174         "SECTORSPERBLOCK/K,"
 175         "RESERVED/K,"
 176         "PREALLOC/K,"
 177         "INTERLEAVE/K,"
 178         "LOWCYL/K,"
 179         "HIGHCYL/K,"
 180         "BUFFERS/K,"
 181         "BUFMEMTYPE/K,"
 182         "MAXTRANSFER/K,"
 183         "MASK/K,"
 184         "BOOTPRI/K,"
 185         "DOSTYPE/K,"
 186         "BAUD/K,"
 187         "CONTROL/K,"
 188         "STACKSIZE/K,"
 189         "PRIORITY/K,"
 190         "GLOBVEC/K,"
 191         "STARTUP/K,"
 192         "MOUNT=ACTIVATE/K,"
 193         "FORCELOAD/K";
 194
 195 #ifdef __MORPHOS__
 196 #define PROGNAME "Mount unofficial"
 197 #define __stackparm __attribute__((varargs68k))
 198 typedef struct Library *UtilityBase_t;
 199 #else
 200 #define PROGNAME "Mount"
 201 typedef struct UtilityBase *UtilityBase_t;
 202 #endif
 203
 204 #ifdef __PPC__
 205 #define ARGS(ap) ap->overflow_arg_area
 206 #else
 207 #define ARGS(ap) (IPTR *)ap
 208 #endif
 209
 210 #ifdef __AROS__
 211 #define _WBenchMsg WBenchMsg
 212 #endif
 213
 214 #ifdef AROS_FAST_BPTR
 215 #define BSTR_EXTRA 1
 216 #define BSTR_OFFSET 0
 217 #define bstrcpy(dest, src, len) strcpy(dest, src)
 218 #else
 219 #define BSTR_EXTRA 2
 220 #define BSTR_OFFSET 1
 221 #define bstrcpy(dest, src, len) \
 222         dest[0] = len; \
 223         strcpy(&dest[1], src);
 224 #endif
 225
 226 static const int __nocommandline;
 227 const TEXT version[] = "\0$VER: " PROGNAME " 50.14 (10.1.2008)";
 228
 229 ULONG CheckDevice(char *name);
 230 void  InitParams(IPTR *params);
 231 LONG  readfile(STRPTR name, STRPTR *mem, LONG *size);
 232 ULONG readmountlist(IPTR *params, STRPTR name, char *mountlist);
 233 ULONG readmountfile(IPTR *params, STRPTR name);
 234 void preparefile(STRPTR buf, LONG size);
 235 LONG parsemountfile(IPTR *params, STRPTR buf, LONG size);
 236 LONG parsemountlist(IPTR *params, STRPTR name, STRPTR buf, LONG size);
 237 LONG mount(IPTR *params, STRPTR name);
 238 void __stackparm ShowError(char *s, ...);
 239 void ShowFault(LONG code, char *s, ...);
 240
 241 struct DosLibrary *DOSBase;
 242 struct IntuitionBase *IntuitionBase;
 243 UtilityBase_t UtilityBase;
 244 struct Process *MyProcess;
 245
 246 ULONG StartupValue;
 247 char *StartupString = NULL;
 248 char *ControlString = NULL;
 249 char *UnitString = NULL;
 250 char *FlagsString = NULL;
 251 ULONG StackSize;
 252 ULONG Priority;
 253 ULONG Activate;
 254 int   GlobalVec;
 255 ULONG ForceLoad;
 256 char *HandlerString;
 257 char *DeviceString;
 258 BOOL  IsEHandler, IsFilesystem;
 259 BOOL  IsCli;
 260 BOOL flagargs[NUM_ARGS];
 261 extern struct WBStartup *_WBenchMsg;
 262
 263 int main(void)
 264 {
 265   STRPTR args[2];
 266   IPTR *params;
 267   LONG error = RETURN_FAIL;
 268   struct RDArgs *rda;
 269   char dirname[512];
 270
 271   if ((DOSBase = (struct DosLibrary *)OpenLibrary("dos.library",37))!=0)
 272   {
 273     if ((UtilityBase = (UtilityBase_t)OpenLibrary("utility.library",37)))
 274     {
 275         memset(&flagargs, 0, sizeof(flagargs));
 276         IsEHandler = TRUE;
 277         IsFilesystem = TRUE;
 278         if (!_WBenchMsg)
 279         {
 280           memset(args,0,sizeof(args));
 281           if ((rda = ReadArgs("DEVICE/M,FROM/K", (IPTR *)args, NULL)))
 282           {
 283             STRPTR      *MyDevPtr;
 284             int         len;
 285
 286             error = 0;
 287
 288             MyDevPtr    =(STRPTR *)args[0];
 289             if (MyDevPtr)
 290             {
 291               while (*MyDevPtr)
 292               {
 293                 DEBUG_MOUNT(Printf("Mount: Current DevName <%s>\n",
 294                                    (ULONG)*MyDevPtr));
 295
 296                 if ((params = AllocVec(PARAMSLENGTH, MEMF_PUBLIC | MEMF_CLEAR)))
 297                 {
 298                   StackSize     = 8192;
 299                   Priority      = 5;
 300                   GlobalVec     = -1;
 301                   HandlerString = NULL;
 302                   DeviceString  = NULL;
 303                   StartupString = NULL;
 304
 305                   len = strlen(*MyDevPtr);
 306                   if ((*MyDevPtr)[len-1] == ':')
 307                   {
 308                     /* search for a devicename */
 309                     DEBUG_MOUNT(Printf("Mount: search for devname <%s>\n",
 310                                        (ULONG)*MyDevPtr));
 311
 312                     strcpy(dirname, *MyDevPtr);
 313                     dirname[len-1] = '\0';
 314
 315                     if ((error=CheckDevice(dirname))!=RETURN_OK)
 316                     {
 317                       DEBUG_MOUNT(Printf("Mount: is already mounted..stop\n"));
 318                     }
 319                     else
 320                     {
 321                       if (args[1])
 322                       {
 323                         error=readmountlist(params, dirname, args[1]);
 324                         DEBUG_MOUNT(Printf("Mount: readmountlist(%s) returned %ld\n", args[1], error));
 325                       }
 326                       else
 327                       {
 328                         char    **SearchPtr;
 329                         ULONG   slen;
 330
 331                         DEBUG_MOUNT(Printf("Mount: search device definition <%s>\n",
 332                                            (ULONG)*MyDevPtr));
 333                         for (SearchPtr=(char**) SearchTable;
 334                              *SearchPtr;
 335                              SearchPtr++)
 336                         {
 337                           if(SetSignal(0L,SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
 338                           {
 339                             error = RETURN_FAIL;
 340                             SetIoErr(ERROR_BREAK);
 341                             break;
 342                           }
 343
 344                           slen = strlen(*SearchPtr);
 345                           strcpy(dirname, *SearchPtr);
 346                           dirname[slen] = '\0';
 347                           strcat(dirname, *MyDevPtr);
 348                           dirname[slen+len-1] = '\0';
 349                           DEBUG_MOUNT(Printf("Mount: try File <%s>\n", (ULONG)dirname));
 350
 351                           error=readmountfile(params, dirname);
 352                           DEBUG_MOUNT(Printf("Mount: readmountfile returned %ld\n", error));
 353                           if (error != ERROR_OBJECT_NOT_FOUND)
 354                             break;
 355                         }
 356                         if (error == ERROR_OBJECT_NOT_FOUND)
 357                         {
 358                           DEBUG_MOUNT(Printf("Mount: try from mountlist\n"));
 359                           dirname[0] = '\0';
 360                           strcat(dirname, *MyDevPtr);
 361                           dirname[len-1] = '\0';
 362                           error=readmountlist(params, dirname, MOUNTLIST);
 363                           DEBUG_MOUNT(Printf("Mount: readmountlist(default) returned %ld\n", error));
 364                         }
 365                       }
 366                     }
 367                   }
 368                   else
 369                   {
 370                     /* search for a filename */
 371
 372                     LONG err;
 373
 374                     UBYTE stack_ap[sizeof(struct AnchorPath) + 3];
 375                     struct AnchorPath   *MyAp = (struct AnchorPath *) (((ULONG) stack_ap + 3) & ~3);
 376
 377                     DEBUG_MOUNT(Printf("Mount: search for mountfile <%s>\n",
 378                                        (ULONG)*MyDevPtr));
 379
 380                     memset(MyAp,0,sizeof(struct AnchorPath));
 381
 382                     dirname[0]  =       '\0';
 383                     for (err = MatchFirst(*MyDevPtr,MyAp);
 384                          err == 0;
 385                          err = MatchNext(MyAp))
 386                     {
 387                       if (MyAp->ap_Flags & APF_DirChanged)
 388                       {
 389                         DEBUG_MOUNT(Printf("Mount: Changed directories...\n"));
 390                       }
 391
 392                       if (NameFromLock(MyAp->ap_Current->an_Lock,
 393                                        dirname,
 394                                        sizeof(dirname)) == FALSE)
 395                       {
 396                         ShowFault(IoErr(), "Error on NameFromLock");
 397                         break;
 398                       }
 399                       if (AddPart(dirname,
 400                                   &(MyAp->ap_Info.fib_FileName[0]),
 401                                   sizeof(dirname)) == FALSE)
 402                       {
 403                         ShowFault(IoErr(), "Error on AddPart");
 404                         break;
 405                       }
 406                       if (MyAp->ap_Info.fib_DirEntryType > 0)
 407                       {
 408                         if (MyAp->ap_Flags & APF_DIDDIR)
 409                         {
 410                           DEBUG_MOUNT(Printf("Mount: Ascending from directory %s\n",
 411                                         (ULONG)dirname));
 412                         }
 413                         else
 414                         {
 415                           DEBUG_MOUNT(Printf("Mount: The next dir is  ... %s\n", (ULONG)dirname));
 416                         }
 417                         /* clear the completed directory flag */
 418                         MyAp->ap_Flags     &=      ~APF_DIDDIR;
 419
 420                       }
 421                       else
 422                       {
 423                         /* Here is code for handling each particular file */
 424
 425                         DEBUG_MOUNT(Printf("Mount: try File <%s>\n",
 426                                            (ULONG)dirname));
 427
 428                         memset(&flagargs, 0, sizeof(flagargs));
 429                         IsEHandler = TRUE;
 430                         IsFilesystem = TRUE;
 431                         error=readmountfile(params, dirname);
 432                         DEBUG_MOUNT(Printf("Mount: readmount file returned %ld\n", error));
 433                       }
 434                     }
 435                     /* This absolutely, positively must be called, all of the time. */
 436                     MatchEnd(MyAp);
 437
 438                     if (err == ERROR_NO_MORE_ENTRIES)
 439                     {
 440                       SetIoErr(0);
 441                     }
 442                     else
 443                     {
 444                       /* if it was real error promote it - Piru */
 445                       error = err;
 446                     }
 447                   }
 448                   FreeVec(params);
 449                 }
 450                 else
 451                 {
 452                   error = ERROR_NO_FREE_STORE;
 453                   break;
 454                 }
 455                 MyDevPtr++;
 456               }
 457             }
 458             FreeArgs(rda);
 459           } /* if (rda != NULL) */
 460           else
 461           {
 462             error = IoErr();
 463           }
 464
 465           if (error && error != ERROR_NO_MORE_ENTRIES && error < ERR_SPECIAL)
 466           {
 467             ShowFault(error, "ERROR");
 468
 469             error = RETURN_FAIL;
 470           }
 471           else
 472           {
 473             error = error < ERR_SPECIAL ? RETURN_OK : RETURN_FAIL;
 474           }
 475
 476         }
 477         else
 478         {
 479           /* wb startup */
 480           if (_WBenchMsg->sm_NumArgs >= 2)
 481           {
 482             if ((params = AllocVec(PARAMSLENGTH,
 483                                    MEMF_PUBLIC | MEMF_CLEAR)))
 484             {
 485               int i;
 486
 487               for (i = 1; i < _WBenchMsg->sm_NumArgs; i++)
 488               {
 489                 BPTR olddir;
 490
 491                 DEBUG_MOUNT(kprintf("Mount: try File <%s>\n",
 492                                    (ULONG) _WBenchMsg->sm_ArgList[i].wa_Name));
 493
 494                 olddir = CurrentDir(_WBenchMsg->sm_ArgList[i].wa_Lock);
 495
 496                 error=readmountfile(params, _WBenchMsg->sm_ArgList[i].wa_Name);
 497                 DEBUG_MOUNT(kprintf("Mount: readmountfile returned %ld\n", error));
 498                 if (error && error != ERROR_NO_MORE_ENTRIES && error < ERR_SPECIAL)
 499                   ShowFault(error, "ERROR");
 500
 501                 (void) CurrentDir(olddir);
 502               }
 503
 504               FreeVec(params);
 505             }
 506             else
 507             {
 508               error = ERROR_NO_FREE_STORE;
 509             }
 510           }
 511         }
 512         CloseLibrary((struct Library *)UtilityBase);
 513     }
 514     CloseLibrary((struct Library *)DOSBase);
 515   }
 516
 517   return error;
 518 }
 519
 520 /************************************************************************************************/
 521 /************************************************************************************************/
 522 ULONG CheckDevice(char *name)
 523 {
 524 struct DosList  *dl;
 525 ULONG           Status;
 526
 527   DEBUG_CHECK(Printf("CheckDevice: <%s>\n",
 528                      name));
 529
 530   dl = LockDosList(LDF_DEVICES | LDF_VOLUMES | LDF_ASSIGNS | LDF_READ);
 531   if ((dl = FindDosEntry(dl,name,LDF_DEVICES | LDF_VOLUMES | LDF_ASSIGNS)))
 532   {
 533     Status      =       ERROR_OBJECT_EXISTS;
 534   }
 535   else
 536   {
 537     Status      =       0;
 538   }
 539   UnLockDosList(LDF_DEVICES | LDF_VOLUMES | LDF_ASSIGNS | LDF_READ);
 540
 541   DEBUG_CHECK(Printf("CheckDevice: object %sexist\n", Status ? "does" : "doesn't "));
 542
 543   return Status;
 544 }
 545
 546 /************************************************************************************************/
 547 /************************************************************************************************/
 548
 549 void InitParams(IPTR *params)
 550 {
 551   struct DosEnvec *vec;
 552
 553   memset(params,0, PARAMSLENGTH);
 554
 555   vec = (struct DosEnvec *)&params[4];
 556
 557   vec->de_TableSize      = DE_BOOTBLOCKS;
 558   vec->de_SizeBlock      = 512 >> 2;
 559   vec->de_Surfaces       = 2;
 560   vec->de_SectorPerBlock = 1;
 561   vec->de_BlocksPerTrack = 11;
 562   vec->de_Reserved       = 2;
 563
 564 /* memset above
 565   vec->de_SecOrg         = 0;
 566   vec->de_BootBlocks     = 0;
 567   vec->de_BootPri        = 0;
 568   vec->de_PreAlloc       = 0;
 569   vec->de_Interleave     = 0;
 570   vec->de_LowCyl         = 0;
 571 */
 572
 573   vec->de_HighCyl        = 79;
 574   vec->de_NumBuffers     = 20; /* On AmigaOS 3.9 it's 5 */
 575   vec->de_BufMemType     = 3;
 576   vec->de_Baud           = 1200;
 577   vec->de_MaxTransfer    = 0x7fffffff;
 578   vec->de_Mask           = 0xfffffffe;
 579   vec->de_DosType        = ID_DOS_DISK;
 580
 581   StackSize              = 8192;
 582   Priority               = 5;
 583   GlobalVec              = -1;
 584   HandlerString          = NULL;
 585   DeviceString           = NULL;
 586   StartupString          = NULL;
 587 }
 588
 589 void FreeStuff(void)
 590 {
 591   if (UnitString)
 592   {
 593     FreeVec(UnitString);
 594     UnitString = NULL;
 595   }
 596   if (FlagsString)
 597   {
 598     FreeVec(FlagsString);
 599     FlagsString = NULL;
 600   }
 601   if (ControlString)
 602   {
 603     FreeVec(ControlString);
 604     ControlString = NULL;
 605   }
 606   if (HandlerString)
 607   {
 608     FreeVec(HandlerString);
 609     HandlerString = NULL;
 610   }
 611   if (DeviceString)
 612   {
 613     FreeVec(DeviceString);
 614     DeviceString = NULL;
 615   }
 616   if (StartupString)
 617   {
 618     FreeVec(StartupString);
 619     StartupString = NULL;
 620   }
 621 }
 622
 623 /************************************************************************************************/
 624 /************************************************************************************************/
 625
 626 ULONG GetValue(char *buf, char **end)
 627 {
 628         int base;
 629         char *c = buf;
 630
 631         /* I decided to leave this routine in order to prevent reading numbers starting from '0'
 632            as octal. Probably this is not needed, or octal support would not do any harm, in this
 633            case this routine is not needed at all - Pavel Fedin */
 634         if ((c[0]=='-') || (c[1]=='+'))
 635                 c++;
 636         if ((c[0] == '0') && (((c[1])=='x') || (c[1])=='X'))
 637                 base = 16;
 638         else
 639                 base = 10;
 640         return strtol(buf,end,base);
 641 /* Left for reference - Pavel Fedin
 642 ULONG   Value;
 643 ULONG   Sign;
 644   Value = 0;
 645   Sign = 1;
 646   if (buf[0]=='-')
 647   {
 648     Sign = -1;
 649     buf++;
 650   }
 651   else
 652   if (buf[0]=='+')
 653   {
 654     buf++;
 655   }
 656
 657   if ((buf[0] == '0') && (((buf[1])=='x') || (buf[1])=='X'))
 658   {
 659     int num;
 660
 661     // base = hex
 662     buf+=2;
 663     while(*buf)
 664     {
 665       Value<<=4;
 666       num=*buf++;
 667
 668       if((num >= 0x30) && (num <= 0x39))
 669       {
 670         num-=0x30;
 671         Value+=num;
 672       }
 673       else
 674       {
 675         num |= 0x20;
 676
 677         if((num >= 0x61) && (num <= 0x66))
 678         {
 679           num-=(0x61-10);
 680           Value+=num;
 681         }
 682       }
 683     }
 684   }
 685   else
 686   {
 687     // base = dev
 688     Value=atoi(buf);
 689   }
 690   return Value * Sign;
 691 */
 692 }
 693
 694 /************************************************************************************************/
 695 /************************************************************************************************/
 696
 697 ULONG ReadMountArgs(IPTR *params, struct RDArgs *rda)
 698 {
 699         struct DosEnvec *vec;
 700         STRPTR args[NUM_ARGS];
 701         struct RDArgs *MyRDA;
 702         ULONG result = RETURN_OK;
 703         int i;
 704         char *s = NULL;
 705
 706         DEBUG_MOUNT(Printf("ReadMountArgs:\n%s\n\n",(ULONG)&rda->RDA_Source.CS_Buffer[rda->RDA_Source.CS_CurChr]));
 707
 708         memset(&args, 0, sizeof(args));
 709
 710         if (!(MyRDA = ReadArgs((STRPTR)options, (IPTR *)args, rda)))
 711         {
 712                 DEBUG_MOUNT(Printf("ReadMountArgs: ReadArgs failed\n"));
 713                 DEBUG_MOUNT(PrintFault(IoErr(),"ReadMountArgs"));
 714                 //return (ULONG) IoErr();
 715                 return  ERR_INVALIDKEYWORD;
 716         }
 717
 718         for (i = 0; i < NUM_ARGS; i++)
 719         {
 720                 if (args[i] != NULL)
 721                 {
 722                         flagargs[i] = TRUE;
 723                 }
 724         }
 725
 726         if (args[ARG_HANDLER] != NULL)
 727         {
 728                 s = (STRPTR)args[ARG_HANDLER];
 729                 IsEHandler = FALSE;
 730                 IsFilesystem = FALSE;
 731         }
 732         else if (args[ARG_EHANDLER] != NULL)
 733         {
 734                 s = (STRPTR)args[ARG_EHANDLER];
 735                 IsEHandler = TRUE;
 736                 IsFilesystem = FALSE;
 737         }
 738         else if (args[ARG_FILESYSTEM] != NULL)
 739         {
 740                 s = (STRPTR)args[ARG_FILESYSTEM];
 741                 IsEHandler = TRUE;
 742                 IsFilesystem = TRUE;
 743         } else
 744                 s = NULL;
 745         if (s)
 746         {
 747                 int len;
 748                 DEBUG_MOUNT(Printf("ReadMountArgs: Handler <%s>\n",s));
 749                 len = strlen(s);
 750                 if (HandlerString)
 751                 {
 752                         FreeVec(HandlerString);
 753                 }
 754                 if ((HandlerString = AllocVec(len + BSTR_EXTRA, MEMF_PUBLIC|MEMF_CLEAR)))
 755                 {
 756                         bstrcpy(HandlerString, s, len);
 757                 }
 758         }
 759         if (args[ARG_STACKSIZE] != NULL)
 760         {
 761                 StackSize = GetValue(args[ARG_STACKSIZE], NULL);
 762         }
 763
 764         if (args[ARG_PRIORITY] != NULL)
 765         {
 766                 Priority = GetValue(args[ARG_PRIORITY], NULL);
 767         }
 768
 769         if (args[ARG_GLOBVEC] != NULL)
 770         {
 771                 GlobalVec = GetValue(args[ARG_GLOBVEC], NULL);
 772         }
 773
 774         if (args[ARG_FORCELOAD] != NULL)
 775         {
 776                 ForceLoad = GetValue((STRPTR)args[ARG_FORCELOAD], NULL);
 777         }
 778
 779         if (args[ARG_ACTIVATE] != NULL)
 780         {
 781                 Activate = GetValue(args[ARG_ACTIVATE], NULL);
 782         }
 783
 784         if (args[ARG_DEVICE] != NULL)
 785         {
 786                 int len;
 787
 788                 DEBUG_MOUNT(Printf("ReadMountArgs: Device <%s>\n",args[ARG_DEVICE]));
 789
 790                 len = strlen((STRPTR)args[ARG_DEVICE]);
 791
 792                 if (DeviceString)
 793                 {
 794                         FreeVec(DeviceString);
 795                 }
 796                 if ((DeviceString = AllocVec(len+1,MEMF_PUBLIC|MEMF_CLEAR)))
 797                 {
 798                         //Printf("copying...\n");
 799
 800                         strcpy(DeviceString, args[ARG_DEVICE]);
 801                 }
 802         }
 803
 804         if (args[ARG_UNIT] != NULL)
 805         {
 806                 if (UnitString)
 807                 {
 808                         FreeVec(UnitString);
 809                         UnitString = NULL;
 810                 }
 811                 params[2] = GetValue(args[ARG_UNIT], &s);
 812                 if (*s)
 813                 {
 814                         int len;
 815
 816                         len = strlen(args[ARG_UNIT]);
 817
 818                         DEBUG_MOUNT(Printf("ReadMountArgs: len %ld\n",len));
 819
 820                         if ((UnitString = AllocVec(len + 1, MEMF_PUBLIC|MEMF_CLEAR)))
 821                         {
 822                                 strcpy(UnitString, args[ARG_UNIT]);
 823                                 params[2] = (IPTR)UnitString;
 824                                 DEBUG_MOUNT(Printf("ReadMountArgs: Unit String <%s>\n", (STRPTR)params[2]));
 825                         }
 826                         else
 827                         {
 828                                 result = ERROR_NO_FREE_STORE;
 829                                 goto error;
 830                         }
 831                 }
 832                 else
 833                         DEBUG_MOUNT(Printf("ReadMountArgs: Unit Value %ld\n",params[2]));
 834         }
 835         if (args[ARG_FLAGS] != NULL)
 836         {
 837 //                      char *String;
 838
 839                 DEBUG_MOUNT(Printf("ReadMountArgs: Flags <%s>\n",args[ARG_FLAGS]));
 840                 if (FlagsString)
 841                 {
 842                         FreeVec(FlagsString);
 843                         FlagsString = NULL;
 844                 }
 845 /*
 846                 String  =       args[ARG_FLAGS];
 847
 848                 if ((*String >= 0x30) && (*String <= 0x39))
 849                 {
 850                         params[3] = GetValue(String);
 851                         DEBUG_MOUNT(Printf("ReadMountArgs: Flag Value %ld\n",params[3]));
 852                 }
 853                 else
 854 */
 855                 params[3] = GetValue(args[ARG_FLAGS], &s);
 856                 if (*s)
 857                 {
 858                         int len;
 859
 860                         len = strlen(args[ARG_FLAGS]);
 861
 862                         DEBUG_MOUNT(Printf("ReadMountArgs: len %ld\n",len));
 863
 864                         if ((FlagsString = AllocVec(len + 1, MEMF_PUBLIC|MEMF_CLEAR)))
 865                         {
 866                                 strcpy(FlagsString, args[ARG_FLAGS]);
 867                                 params[3] = (IPTR) FlagsString;
 868                                 DEBUG_MOUNT(Printf("ReadMountArgs: Flags String <%s>\n",(STRPTR)params[3]));
 869                         }
 870                         else
 871                         {
 872                                 result = ERROR_NO_FREE_STORE;
 873                                 goto error;
 874                         }
 875                 }
 876                 else
 877                         DEBUG_MOUNT(Printf("ReadMountArgs: Flag Value %ld\n",params[3]));
 878         }
 879
 880         vec = (struct DosEnvec *)&params[4];
 881
 882         if (args[ARG_BLOCKSIZE] != NULL)
 883         {
 884                 vec->de_SizeBlock = GetValue(args[ARG_BLOCKSIZE], NULL) >> 2;
 885         }
 886         if (args[ARG_SURFACES] != NULL)
 887         {
 888                 vec->de_Surfaces = GetValue(args[ARG_SURFACES], NULL);
 889         }
 890         if (args[ARG_SECTORSPERBLOCK] != NULL)
 891         {
 892                 vec->de_SectorPerBlock = GetValue(args[ARG_SECTORSPERBLOCK], NULL);
 893         }
 894         if (args[ARG_BLOCKSPERTRACK] != NULL)
 895         {
 896                 vec->de_BlocksPerTrack = GetValue(args[ARG_BLOCKSPERTRACK], NULL);
 897         }
 898         if (args[ARG_RESERVED] != NULL)
 899         {
 900                 vec->de_Reserved = GetValue(args[ARG_RESERVED], NULL);
 901         }
 902         if (args[ARG_PREALLOC] != NULL)
 903         {
 904                 vec->de_PreAlloc = GetValue(args[ARG_PREALLOC], NULL);
 905         }
 906         if (args[ARG_INTERLEAVE] != NULL)
 907         {
 908                 vec->de_Interleave = GetValue(args[ARG_INTERLEAVE], NULL);
 909         }
 910         if (args[ARG_LOWCYL] != NULL)
 911         {
 912                 vec->de_LowCyl = GetValue(args[ARG_LOWCYL], NULL);
 913         }
 914         if (args[ARG_HIGHCYL] != NULL)
 915         {
 916                 vec->de_HighCyl = GetValue(args[ARG_HIGHCYL], NULL);
 917         }
 918         if (args[ARG_BUFFERS] != NULL)
 919         {
 920                 vec->de_NumBuffers = GetValue(args[ARG_BUFFERS], NULL);
 921         }
 922         if (args[ARG_BUFMEMTYPE] != NULL)
 923         {
 924                 vec->de_BufMemType = GetValue(args[ARG_BUFMEMTYPE], NULL);
 925         }
 926         if (args[ARG_BOOTPRI] != NULL)
 927         {
 928                 vec->de_BootPri = GetValue(args[ARG_BOOTPRI], NULL);
 929         }
 930         if (args[ARG_BAUD] != NULL)
 931         {
 932                 vec->de_Baud = GetValue(args[ARG_BAUD], NULL);
 933         }
 934         if (args[ARG_MAXTRANSFER] != NULL)
 935         {
 936                 vec->de_MaxTransfer = GetValue(args[ARG_MAXTRANSFER], NULL);
 937         }
 938         if (args[ARG_MASK] != NULL)
 939         {
 940                 vec->de_Mask = GetValue(args[ARG_MASK], NULL);
 941         }
 942
 943         if (args[ARG_DOSTYPE] != NULL)
 944         {
 945                 vec->de_DosType = (IPTR)GetValue(args[ARG_DOSTYPE], NULL);
 946         }
 947
 948         if (args[ARG_CONTROL] != NULL)
 949         {
 950                 int len;
 951                 DEBUG_MOUNT(Printf("ReadMountArgs: Control <%s>\n",args[ARG_CONTROL]));
 952                 if (ControlString)
 953                 {
 954                         FreeVec(ControlString);
 955                         ControlString = NULL;
 956                 }
 957                 len = strlen(args[ARG_CONTROL]);
 958                 if (len < 0x100)
 959                 {
 960                         if ((ControlString=AllocVec(len + BSTR_EXTRA, MEMF_PUBLIC|MEMF_CLEAR)))
 961                         {
 962                                 bstrcpy(ControlString, args[ARG_CONTROL], len);
 963                                 vec->de_Control = (IPTR)MKBADDR((char*)ControlString);
 964                         }
 965                         else
 966                         {
 967                                 ShowError("Unable to allocate Control string");
 968                                 result = ERROR_NO_FREE_STORE;
 969                                 goto error;
 970                         }
 971                 }
 972                 else
 973                 {
 974                         result = ERROR_LINE_TOO_LONG;
 975                         SetIoErr(result);
 976 //                      ShowError("Control string too long");
 977                         goto error;
 978                 }
 979         }
 980
 981         if (args[ARG_STARTUP] != NULL)
 982         {
 983 //                    char *String;
 984
 985                 DEBUG_MOUNT(Printf("ReadMountArgs: Startup <%s>\n",args[ARG_STARTUP]));
 986                 if (StartupString)
 987                 {
 988                         FreeVec(StartupString);
 989                         StartupString = NULL;
 990                 }
 991 /*
 992                 String = args[ARG_STARTUP];
 993                 if ((*String >= 0x30) && (*String <= 0x39))
 994                 {
 995                         StartupValue = GetValue(String);
 996                 }
 997                 else
 998 */
 999                 StartupValue = GetValue(args[ARG_STARTUP], &s);
1000                 if (*s)
1001                 {
1002                         int len;
1003
1004                         len = strlen(args[ARG_STARTUP]);
1005
1006                         DEBUG_MOUNT(Printf("ReadMountArgs: len %ld\n",len));
1007
1008                         if ((StartupString = AllocVec(len + 1, MEMF_PUBLIC|MEMF_CLEAR)))
1009                         {
1010                                 strcpy(StartupString,args[ARG_STARTUP]);
1011                         }
1012                         else
1013                         {
1014                                 result = ERROR_NO_FREE_STORE;
1015                                 goto error;
1016                         }
1017                 }
1018         }
1019
1020 error:
1021         FreeArgs(MyRDA);
1022
1023         return result;
1024 }
1025
1026 /************************************************************************************************/
1027 /************************************************************************************************/
1028
1029 ULONG   readmountlist(IPTR      *params,
1030                       STRPTR    name,
1031                       char      *mountlist)
1032 {
1033 STRPTR  MountListBuf;
1034 LONG    MountListBufSize;
1035 ULONG   error;
1036
1037   DEBUG_MOUNT(Printf("ReadMountList: find <%s> in mountlist <%s>\n",
1038                      name,
1039                      mountlist));
1040
1041   error = readfile(mountlist,
1042                    &MountListBuf,
1043                    &MountListBufSize);
1044   if (error==RETURN_OK)
1045   {
1046     preparefile(MountListBuf,
1047                 MountListBufSize);
1048
1049
1050     InitParams(params);
1051
1052     if ((error=parsemountlist(params,
1053                               name,
1054                               MountListBuf,
1055                               MountListBufSize))==RETURN_OK)
1056     {
1057       if ((error = mount(params,name))!=RETURN_OK)
1058       {
1059         DEBUG_MOUNT(Printf("ReadMountList: mount failed error %ld\n",
1060                            error));
1061       }
1062     }
1063     else
1064     {
1065       switch (error)
1066       {
1067         case ERR_DEVICENOTFOUND:
1068         case ERR_INVALIDKEYWORD:
1069           ShowError("Device '%s:' not found in file '%s'", name, mountlist);
1070           break;
1071       }
1072     }
1073
1074     FreeStuff();
1075     FreeVec(MountListBuf);
1076   }
1077   return error;
1078 }
1079
1080 /************************************************************************************************/
1081 /************************************************************************************************/
1082
1083 ULONG readmountfile(IPTR *params, STRPTR filename)
1084 {
1085 struct Library          *IconBase;
1086 struct DiskObject       *diskobj;
1087 char                    **myargv;
1088 STRPTR                  MountListBuf;
1089 LONG                    MountListBufSize;
1090 struct RDArgs           rda;
1091 ULONG                   error = RETURN_FAIL;
1092 UBYTE                   *nameptr;
1093 int                     toollen;
1094 BOOL                    mountinfo=FALSE;
1095 char                    name[256+1];
1096
1097   DEBUG_MOUNT(Printf("ReadMountFile: <%s>\n", (ULONG)filename));
1098
1099   {
1100     struct Process *me = (APTR) FindTask(NULL);
1101     APTR oldwinptr;
1102     BPTR lock;
1103
1104     name[0] = '\0';
1105
1106     oldwinptr = me->pr_WindowPtr;
1107     me->pr_WindowPtr = (APTR) -1;
1108     lock = Lock(filename, SHARED_LOCK);
1109     if (lock)
1110     {
1111       struct FileInfoBlock fib;
1112       if (Examine(lock, &fib))
1113       {
1114         nameptr = fib.fib_FileName;
1115         memmove(name, nameptr, strlen(nameptr) + 1);
1116       }
1117       UnLock(lock);
1118     }
1119     me->pr_WindowPtr = oldwinptr;
1120
1121     if (name[0] == '\0')
1122     {
1123       nameptr           =       FilePart(filename);
1124       strcpy(name,
1125              nameptr);
1126     }
1127   }
1128
1129   DEBUG_MOUNT(Printf("ReadMountFile: mount <%s>\n", (ULONG)name));
1130
1131   if ((error=CheckDevice(name))!=RETURN_OK)
1132   {
1133     return error;
1134   }
1135
1136   InitParams(params);
1137
1138   DEBUG_MOUNT(Printf("ReadMountFile: readfile\n"));
1139
1140   error = readfile(filename,
1141                    &MountListBuf,
1142                    &MountListBufSize);
1143   if (error==RETURN_OK)
1144   {
1145     DEBUG_MOUNT(Printf("ReadMountFile: preparsefile\n"));
1146     preparefile(MountListBuf, MountListBufSize);
1147
1148
1149     DEBUG_MOUNT(Printf("ReadMountFile: parsemountfile\n"));
1150     if ((error = parsemountfile(params, MountListBuf, MountListBufSize))!=RETURN_OK)
1151     {
1152       DEBUG_MOUNT(Printf("ReadMountFile: parsemountfile error %ld\n", error));
1153       ShowFault(IoErr(), "Mountfile '%s' is invalid", filename);
1154     }
1155     else
1156     {
1157       mountinfo =       TRUE;
1158     }
1159     FreeVec(MountListBuf);
1160   }
1161   else
1162   {
1163     DEBUG_MOUNT(Printf("ReadMountFile: mountfile not found..search for <%s.info>\n",
1164                        filename));
1165   }
1166
1167   if ((error==RETURN_OK) ||
1168       (error==ERROR_OBJECT_NOT_FOUND))
1169   {
1170     DEBUG_MOUNT(Printf("ReadMountFile: look for icon\n"));
1171
1172     if ((IconBase =  OpenLibrary("icon.library", 37)))
1173     {
1174       if ((diskobj = GetDiskObject(filename)))
1175       {
1176         myargv  =(char**) diskobj->do_ToolTypes;
1177         if (myargv)
1178         {
1179           while (*myargv)
1180           {
1181             char        *ToolPtr;
1182             ToolPtr     =       *myargv;
1183             DEBUG_MOUNT(Printf("ReadMountFile: ToolType <%s>\n",
1184                                ToolPtr));
1185             if ((ToolPtr[0] != '(') && (ToolPtr[0] != '*') &&
1186                 !((ToolPtr[0] == 'I') && (ToolPtr[1] == 'M') && (ToolPtr[3] == '=')))
1187             {
1188               char      *ToolString;
1189               toollen   =       strlen(ToolPtr);
1190               if ((ToolString = AllocVec(toollen + 2,MEMF_ANY)))
1191               {
1192                 memcpy(ToolString,ToolPtr,toollen);
1193                 ToolString[toollen]     =       '\n';
1194                 ToolString[toollen+1]   =       '\0';
1195                 memset(&rda,0,sizeof(struct RDArgs));
1196                 rda.RDA_Source.CS_Buffer = ToolString;
1197                 rda.RDA_Source.CS_Length = toollen+1;
1198                 rda.RDA_Source.CS_CurChr = 0;
1199                 rda.RDA_Flags = RDAF_NOPROMPT;
1200                 if ((ReadMountArgs(params, &rda)==RETURN_OK))
1201                 {
1202                   mountinfo = TRUE;
1203                 }
1204                 else
1205                 {
1206                   DEBUG_MOUNT(Printf("ReadMountFile: ReadArgs failed error %ld\n",
1207                                      error));
1208                 }
1209                 FreeVec(ToolString);
1210               }
1211               else
1212               {
1213                 error = ERROR_NO_FREE_STORE;
1214                 break;
1215               }
1216             }
1217             else
1218             {
1219               DEBUG_MOUNT(Printf("ReadMountFile: skipped\n"));
1220             }
1221             myargv++;
1222           }
1223         }
1224         FreeDiskObject(diskobj);
1225       }
1226       else
1227       {
1228       }
1229       CloseLibrary(IconBase);
1230     }
1231   }
1232
1233   if (mountinfo)
1234   {
1235     DEBUG_MOUNT(Printf("ReadMountFile: mount information exists\n"));
1236
1237     if ((error = mount(params,name)) != RETURN_OK)
1238     {
1239       DEBUG_MOUNT(Printf("ReadMountFile: mount failed error %ld\n",
1240                          error));
1241     }
1242   }
1243
1244   FreeStuff();
1245
1246   return error;
1247 }
1248
1249 /************************************************************************************************/
1250 /************************************************************************************************/
1251
1252
1253 LONG readfile(STRPTR name, STRPTR *mem, LONG *size)
1254 {
1255     BPTR ml;
1256     ULONG rest,sub;
1257     STRPTR buf;
1258     struct Process *me = (struct Process *) FindTask(NULL);
1259     APTR oldwinptr;
1260
1261     oldwinptr = me->pr_WindowPtr;
1262     me->pr_WindowPtr = (APTR) -1;
1263     ml = Open(name, MODE_OLDFILE);
1264     me->pr_WindowPtr = oldwinptr;
1265
1266     DEBUG_MOUNT(Printf("ReadFile: <%s>\n", (LONG) name));
1267
1268     if (ml)
1269     {
1270         if (Seek(ml, 0, OFFSET_END) != -1)
1271         {
1272             *size = Seek(ml, 0, OFFSET_BEGINNING);
1273
1274             if (*size != -1)
1275             {
1276                 *mem = (STRPTR)AllocVec(*size+2, MEMF_ANY);
1277
1278                 if (*mem)
1279                 {
1280                     rest = *size;
1281                     buf = *mem;
1282
1283                     for (;;)
1284                     {
1285                         if (!rest)
1286                         {
1287                             Close(ml);
1288
1289                             *buf++ = '\n';
1290                             *buf = '\0';
1291
1292                             return 0;
1293                         }
1294
1295                         sub = Read(ml, buf, rest);
1296
1297                         if (sub == -1)
1298                         {
1299                             break;
1300                         }
1301
1302                         rest -= sub;
1303                         buf += sub;
1304                     }
1305
1306                     FreeVec(*mem);
1307                 }
1308                 else
1309                 {
1310                     SetIoErr(ERROR_NO_FREE_STORE);
1311                 }
1312             }
1313         }
1314
1315         Close(ml);
1316     }
1317
1318     DEBUG_MOUNT(Printf("ReadFile: error %ld\n", IoErr()));
1319     return IoErr();
1320 }
1321
1322 /************************************************************************************************/
1323 /************************************************************************************************/
1324
1325
1326 void preparefile(STRPTR buf, LONG size)
1327 {
1328     STRPTR end = buf + size;
1329
1330     while (buf < end)
1331     {
1332         /* Convert comments to spaces */
1333         if (buf + 1 < end && *buf == '/' && buf[1] == '*')
1334         {
1335             *buf++ = ' ';
1336             *buf++ = ' ';
1337
1338             while (buf < end)
1339             {
1340                 if (*buf == '*')
1341                 {
1342                     *buf++ = ' ';
1343
1344                     if (buf >= end)
1345                     {
1346                         break;
1347                     }
1348
1349                     if (*buf == '/')
1350                     {
1351                         *buf++ = ' ';
1352                         break;
1353                     }
1354                 }
1355                 else
1356                 {
1357                     *buf++=' ';
1358                 }
1359             }
1360
1361             continue;
1362         }
1363
1364         /* Skip strings */
1365         if (*buf=='\"')
1366         {
1367             /*
1368              * skip first
1369              */
1370             buf++;
1371             while (buf < end && *buf != '\"')
1372             {
1373                 buf++;
1374             }
1375             /*
1376              * skip last "
1377              */
1378             buf++;
1379             continue;
1380         }
1381
1382         /* Convert '\n' and ';' to spaces */
1383         if (*buf == '\n' || *buf == ';')
1384         {
1385             *buf++ = ' ';
1386             continue;
1387         }
1388
1389         /* Convert '#' to \n */
1390         if (*buf == '#')
1391         {
1392             *buf++ = '\n';
1393             continue;
1394         }
1395
1396         /* Skip all other characters */
1397         buf++;
1398     }
1399 }
1400
1401 /************************************************************************************************/
1402 /************************************************************************************************/
1403
1404 struct FileSysEntry *GetFileSysEntry(ULONG DosType)
1405 {
1406
1407   struct FileSysResource *MyFileSysRes;
1408   struct FileSysEntry *MyFileSysEntry;
1409   struct FileSysEntry *CurrentFileSysEntry;
1410
1411   MyFileSysEntry = NULL;
1412   MyFileSysRes = OpenResource(FSRNAME);
1413   if (MyFileSysRes)
1414   {
1415     Forbid();
1416     CurrentFileSysEntry = (struct FileSysEntry*) MyFileSysRes->fsr_FileSysEntries.lh_Head;
1417     while (CurrentFileSysEntry->fse_Node.ln_Succ)
1418     {
1419       if (CurrentFileSysEntry->fse_DosType == DosType)
1420       {
1421         if (MyFileSysEntry)
1422         {
1423           if (CurrentFileSysEntry->fse_Version > MyFileSysEntry->fse_Version)
1424           {
1425             MyFileSysEntry      =       CurrentFileSysEntry;
1426           }
1427         }
1428         else
1429         {
1430           MyFileSysEntry        =       CurrentFileSysEntry;
1431         }
1432       }
1433       CurrentFileSysEntry       =(struct FileSysEntry*) CurrentFileSysEntry->fse_Node.ln_Succ;
1434     }
1435     Permit();
1436   }
1437   return MyFileSysEntry;
1438 }
1439
1440 /************************************************************************************************/
1441 /************************************************************************************************/
1442
1443
1444 void    PatchDosNode(struct DeviceNode  *MyDeviceNode,
1445                      ULONG              DosType)
1446 {
1447 struct FileSysEntry     *MyFileSysEntry;
1448 ULONG                   MyPatchFlags;
1449
1450   DEBUG_PATCHDOSNODE(Printf("MakeDosNode: DeviceNode 0x%lx\n",
1451                     (ULONG)MyDeviceNode));
1452
1453   if ((MyFileSysEntry=GetFileSysEntry(DosType)))
1454   {
1455     MyPatchFlags                =       MyFileSysEntry->fse_PatchFlags;
1456
1457     DEBUG_PATCHDOSNODE(Printf("PatchDosNode: FileSysEntry 0x%lx PatchFlags 0x%lx\n",
1458                       (ULONG)MyFileSysEntry,
1459                       MyPatchFlags));
1460
1461     if (MyPatchFlags)
1462     {
1463       ULONG     *PatchDeviceNode;
1464       ULONG     *PatchDeviceNodeEnd;
1465       ULONG     *PatchFileSysEntry;
1466
1467       PatchFileSysEntry         =(ULONG*) &MyFileSysEntry->fse_Type;
1468       PatchDeviceNode           =(ULONG*) &MyDeviceNode->dn_Type;
1469       PatchDeviceNodeEnd        =(ULONG*) ((ULONG) MyDeviceNode + sizeof(struct DeviceNode));
1470
1471       while (MyPatchFlags)
1472       {
1473         if (MyPatchFlags & 1)
1474         {
1475           *PatchDeviceNode      =       *PatchFileSysEntry;
1476         }
1477         PatchDeviceNode++;
1478         PatchFileSysEntry++;
1479
1480         if (PatchDeviceNode >= PatchDeviceNodeEnd)
1481         {
1482           /* Savety */
1483           break;
1484         }
1485
1486         MyPatchFlags    >>=     1;
1487       }
1488     }
1489   }
1490   else
1491   {
1492     /* Mount with no BootNode */
1493     DEBUG_PATCHDOSNODE(Printf("PatchDosNode: Can't get FileSysEntry..no bootnode\n"));
1494   }
1495 }
1496
1497
1498 /************************************************************************************************/
1499 /************************************************************************************************/
1500
1501
1502
1503 #define DOSNAME_INDEX    0
1504 #define EXECNAME_INDEX   1
1505 #define UNIT_INDEX       2
1506 #define FLAGS_INDEX      3
1507 #define ENVIROMENT_INDEX 4
1508
1509 struct DeviceNode *MyMakeDosNode(char *DosName, IPTR *ParameterPkt, char *StartupName)
1510 {
1511   int DosNameSize;
1512   int ExecNameSize;
1513   int MyEnvSize = 0;
1514   struct DeviceNode *MyDeviceNode = NULL;
1515   struct FileSysStartupMsg *MyFileSysStartupMsg = NULL;
1516   struct DosEnvec *MyDosEnvec = NULL;
1517   char *MyString = NULL;
1518   ULONG Status = FALSE;
1519   DEBUG_MAKEDOSNODE(Printf("MakeDosNode: Pkt 0x%lx\n",(IPTR)ParameterPkt));
1520
1521   if (ParameterPkt)
1522   {
1523     DEBUG_MAKEDOSNODE(Printf("MakeDosNode: DosName <%s> DeviceName <%s> Unit ", DosName, ParameterPkt[EXECNAME_INDEX]));
1524     DEBUG_MAKEDOSNODE(if (UnitString)
1525                              Printf("<%s>",ParameterPkt[UNIT_INDEX]);
1526                       else
1527                              Printf("%ld",ParameterPkt[UNIT_INDEX]);)
1528     DEBUG_MAKEDOSNODE(Printf(" Flags 0x%lx DE_TABLESIZE 0x%lx\n", ParameterPkt[FLAGS_INDEX], ParameterPkt[ENVIROMENT_INDEX]));
1529   }
1530   else
1531   {
1532     DEBUG_MAKEDOSNODE(Printf("MakeDosNode: DosName <%s> Startup <%s>\n", (IPTR)DosName, (IPTR)StartupName));
1533   }
1534
1535   DosNameSize = strlen(DosName);
1536
1537   if (ParameterPkt)
1538   {
1539     if (ParameterPkt[EXECNAME_INDEX])
1540     {
1541       ExecNameSize = strlen((UBYTE *)ParameterPkt[EXECNAME_INDEX]);
1542     }
1543     else
1544     {
1545       ExecNameSize = 0;
1546     }
1547     MyEnvSize = (ParameterPkt[ENVIROMENT_INDEX] + 1) * sizeof(IPTR);
1548   }
1549   else
1550   {
1551     ExecNameSize = StartupName ? strlen(StartupName) : 0;
1552   }
1553
1554   if ((MyDeviceNode = AllocVec(sizeof(struct DeviceNode), MEMF_PUBLIC | MEMF_CLEAR)))
1555   {
1556     DEBUG_MAKEDOSNODE(Printf("MakeDosNode: MyDeviceNode 0x%lx\n", (ULONG)MyDeviceNode));
1557
1558     MyDeviceNode->dn_StackSize = 600;
1559     MyDeviceNode->dn_Priority  = 10;
1560
1561     if ((MyString=AllocVec(((DosNameSize + BSTR_EXTRA + 4) & ~3) + ((ExecNameSize + BSTR_EXTRA + 4) & ~3), MEMF_PUBLIC | MEMF_CLEAR)))
1562     {
1563       bstrcpy(MyString, DosName, DosNameSize);
1564
1565       MyDeviceNode->dn_Name = MKBADDR(MyString);
1566
1567       if (ParameterPkt)
1568       {
1569         if ((MyFileSysStartupMsg = AllocVec(sizeof(struct FileSysStartupMsg), MEMF_PUBLIC | MEMF_CLEAR)))
1570         {
1571           DEBUG_MAKEDOSNODE(Printf("MakeDosNode: MyFileSysStartupMsg 0x%lx\n", (IPTR)MyFileSysStartupMsg));
1572
1573           if ((MyDosEnvec = AllocVec(MyEnvSize, MEMF_PUBLIC | MEMF_CLEAR)))
1574           {
1575             char *ExecNamePtr;
1576
1577             DEBUG_MAKEDOSNODE(Printf("MakeDosNode: MyDosEnvec 0x%lx\n", (IPTR)MyDosEnvec));
1578             ExecNamePtr = &MyString[(1 + DosNameSize + BSTR_EXTRA + 3) & ~3];
1579
1580             /* .device name must absolutely **NOT** include the 0 in the
1581              * length!!
1582              *
1583              * the string *MUST* be 0 terminated, however!
1584              */
1585             if (ParameterPkt[EXECNAME_INDEX])
1586             {
1587               bstrcpy(ExecNamePtr, (UBYTE *)ParameterPkt[EXECNAME_INDEX], ExecNameSize);
1588             }
1589             else
1590             {
1591               ExecNamePtr[0] = 0;
1592 #ifndef AROS_FAST_BPTR
1593               ExecNamePtr[1] = 0;
1594 #endif
1595             }
1596             MyFileSysStartupMsg->fssm_Device  = MKBADDR(ExecNamePtr);
1597             MyFileSysStartupMsg->fssm_Unit    = ParameterPkt[UNIT_INDEX];
1598             MyFileSysStartupMsg->fssm_Flags   = ParameterPkt[FLAGS_INDEX];
1599             MyFileSysStartupMsg->fssm_Environ = MKBADDR(MyDosEnvec);
1600             MyDeviceNode->dn_Startup          = MKBADDR(MyFileSysStartupMsg);
1601
1602             CopyMem(&ParameterPkt[ENVIROMENT_INDEX], MyDosEnvec, MyEnvSize);
1603
1604             Status=TRUE;
1605             DEBUG_MAKEDOSNODE(Printf("MakeDosNode: done\n"));
1606           }
1607         }
1608       }
1609       else
1610       {
1611         if (StartupName && ExecNameSize)
1612         {
1613           char  *StartupNamePtr;
1614
1615           StartupNamePtr = &MyString[(1 + DosNameSize + BSTR_EXTRA + 3) & ~3];
1616           bstrcpy(StartupNamePtr, StartupName, ExecNameSize);
1617           MyDeviceNode->dn_Startup = MKBADDR(StartupNamePtr);
1618         }
1619         Status=TRUE;
1620       }
1621     }
1622   }
1623   if (Status)
1624   {
1625     DEBUG_MAKEDOSNODE(Printf("MakeDosNode: done\n"));
1626     return MyDeviceNode;
1627   }
1628   else
1629   {
1630     DEBUG_MAKEDOSNODE(Printf("MakeDosNode: failed\n"));
1631     FreeVec(MyFileSysStartupMsg);
1632     FreeVec(MyDeviceNode);
1633     FreeVec(MyString);
1634     return NULL;
1635   }
1636 }
1637
1638
1639
1640 /************************************************************************************************/
1641 /************************************************************************************************/
1642
1643
1644 LONG parsemountfile(IPTR *params, STRPTR buf, LONG size)
1645 {
1646 STRPTR args[NUM_ARGS];
1647 LONG   error;
1648 struct RDArgs rda;
1649
1650     DEBUG_MOUNT(Printf("ParseMountFile:\n"));
1651
1652     memset(&args, 0, sizeof(args));
1653     memset(&rda,0,sizeof(struct RDArgs));
1654
1655     rda.RDA_Source.CS_Buffer = buf;
1656     rda.RDA_Source.CS_Length = size;
1657     rda.RDA_Source.CS_CurChr = 0;
1658     rda.RDA_Flags = RDAF_NOPROMPT;
1659
1660     DEBUG_MOUNT(Printf("ReadArgs..\n%s\n\n",(ULONG)rda.RDA_Source.CS_Buffer));
1661
1662     if ((error=ReadMountArgs(params,
1663                             &rda))!=RETURN_OK)
1664     {
1665         DEBUG_MOUNT(Printf("Parse: ReadArgs failed\n"));
1666     }
1667     return error;
1668 }
1669
1670 /************************************************************************************************/
1671 /************************************************************************************************/
1672
1673
1674 LONG    parsemountlist(IPTR             *params,
1675                        STRPTR           name,
1676                        STRPTR           buf,
1677                        LONG             size)
1678 {
1679 STRPTR args[NUM_ARGS];
1680 UBYTE  buffer[1024];
1681 LONG   error=RETURN_OK, res;
1682 STRPTR end = buf + size;
1683 STRPTR s2;
1684 char *ptr;
1685 struct RDArgs rda;
1686
1687     DEBUG_MOUNT(Printf("ParseMountList: <%s>\n",(ULONG)name));
1688
1689     memset(&args,0,sizeof(args));
1690     memset(&rda,0,sizeof(struct RDArgs));
1691
1692     rda.RDA_Source.CS_Buffer = buf;
1693     rda.RDA_Source.CS_Length = end - buf;
1694     rda.RDA_Source.CS_CurChr = 0;
1695     rda.RDA_Flags = RDAF_NOPROMPT;
1696
1697     while (rda.RDA_Source.CS_CurChr < rda.RDA_Source.CS_Length)
1698     {
1699         res = ReadItem(buffer, sizeof(buffer), &rda.RDA_Source);
1700
1701         DEBUG_MOUNT(Printf("ParseMountList: buffer <%s>\n",(ULONG)buffer));
1702         DEBUG_MOUNT(Printf("ParseMountList: ReadItem res %ld\n",res));
1703
1704         if (res == ITEM_ERROR)
1705         {
1706             return IoErr();
1707         }
1708
1709         if (res == ITEM_NOTHING &&
1710             rda.RDA_Source.CS_CurChr == rda.RDA_Source.CS_Length)
1711         {
1712             return 0;
1713         }
1714
1715         if (res != ITEM_QUOTED && res != ITEM_UNQUOTED)
1716         {
1717             return 1;
1718         }
1719
1720         s2 = buffer;
1721
1722         while (*s2)
1723         {
1724             s2++;
1725         }
1726
1727         if (s2 == buffer || s2[-1] != ':')
1728         {
1729             DEBUG_MOUNT(Printf("ParseMountList: failure\n"));
1730             return ERR_DEVICENOTFOUND;
1731         }
1732
1733         *--s2 = 0;
1734
1735         if (!Strnicmp(name, buffer, s2 - buffer) &&
1736            (!name[s2 - buffer] || (name[s2 - buffer] == ':' || !name[s2 - buffer + 1])))
1737         {
1738             DEBUG_MOUNT(Printf("ParseMountList: found\n"));
1739
1740             /* Copy the string so we get proper case - Piru */
1741             memcpy(name, buffer, s2 - buffer);
1742             name[s2 - buffer] = '\0';
1743
1744             ptr = name;
1745             while (*ptr)
1746             {
1747                 if (*ptr++ == ':')
1748                 {
1749                         ptr[-1] = '\0';
1750                         break;
1751                 }
1752             }
1753
1754             DEBUG_MOUNT(Printf("ReadArgs..\n%s\n\n",(ULONG)&rda.RDA_Source.CS_Buffer[rda.RDA_Source.CS_CurChr]));
1755
1756             if ((error=ReadMountArgs(params,
1757                                      &rda))!=RETURN_OK)
1758             {
1759                 DEBUG_MOUNT(Printf("ParseMountList: ReadArgs failed\n"));
1760                 //return IoErr();
1761             }
1762
1763             return error;
1764         }
1765
1766         while (rda.RDA_Source.CS_CurChr < rda.RDA_Source.CS_Length)
1767         {
1768             if (rda.RDA_Source.CS_Buffer[rda.RDA_Source.CS_CurChr++] == '\n')
1769             {
1770                 DEBUG_MOUNT(Printf("ParseMountList: reach the end of the block\n"));
1771                 break;
1772             }
1773         }
1774     }
1775
1776     DEBUG_MOUNT(Printf("ParseMountList: mount found nothing\n"));
1777     return ERR_DEVICENOTFOUND;
1778 }
1779
1780 /************************************************************************************************/
1781 /************************************************************************************************/
1782
1783 LONG checkmount(IPTR *params)
1784 {
1785 struct DosEnvec *vec;
1786
1787         vec = (struct DosEnvec *)&params[4];
1788
1789         params[1] = (IPTR) DeviceString;
1790
1791         if (IsFilesystem && (!flagargs[ARG_DEVICE]
1792             || !flagargs[ARG_SURFACES] || !flagargs[ARG_BLOCKSPERTRACK]
1793             || !flagargs[ARG_LOWCYL] || !flagargs[ARG_HIGHCYL]))
1794         {
1795                 ShowError("Could not find some of the following keywords:\n"
1796                    "       Surfaces, BlocksPerTrack, LowCyl, HighCyl, Device");
1797                 return ERR_INVALIDKEYWORD;
1798         }
1799         /* bootpri -129 shouldn't be started and not automatic mounted..whatever that means */
1800         if ((vec->de_BootPri < -129) || (vec->de_BootPri > 127))
1801         {
1802             ShowError("BootPri %ld is not allowed. Legal range is -128..127",vec->de_BootPri);
1803             return ERROR_BAD_NUMBER;
1804         }
1805
1806         if (flagargs[ARG_GLOBVEC])
1807         {
1808                 if ((GlobalVec != -1) && (GlobalVec != -2))
1809                 {
1810                     ShowError("Globvec %ld is not supported. Only -1 and -2 are supported here", GlobalVec);
1811                     return ERROR_BAD_NUMBER;
1812                 }
1813         }
1814
1815         if (flagargs[ARG_STARTUP] && !StartupString)
1816         {
1817                 if (StartupValue >= 0x100)
1818                 {
1819                         ShowError("Startup uses a too large numerical number %ld",StartupValue);
1820                         return ERROR_BAD_NUMBER;
1821                 }
1822         }
1823
1824         return RETURN_OK;
1825 }
1826
1827 /************************************************************************************************/
1828 /************************************************************************************************/
1829
1830 LONG mount(IPTR *params, STRPTR name)
1831 {
1832     struct DosEnvec *vec;
1833     LONG error = RETURN_OK;
1834     struct DeviceNode *dn;
1835
1836     strupr(name);
1837     DEBUG_MOUNT(Printf("MountDev: <%s>\n",(ULONG)name));
1838
1839     if ((error=checkmount(params))!=RETURN_OK)
1840     {
1841         DEBUG_MOUNT(Printf("MountDev: checkmount failed\n"));
1842         return error;
1843     }
1844
1845     vec = (struct DosEnvec *)&params[4];
1846
1847     DEBUG_MOUNT(Printf("MountDev: DosName         <%s>\n",(ULONG)name));
1848     DEBUG_MOUNT(Printf("MountDev: Filesystem      <%s>\n",(ULONG)HandlerString + BSTR_OFFSET));
1849     DEBUG_MOUNT(Printf("MountDev: Device          <%s>\n",(ULONG)DeviceString));
1850     DEBUG_MOUNT(Printf("MountDev: TableSize       %ld\n",vec->de_TableSize));
1851     DEBUG_MOUNT(Printf("MountDev: SizeBlock       %ld\n",vec->de_SizeBlock));
1852     DEBUG_MOUNT(Printf("MountDev: SecOrg          %ld\n",vec->de_SecOrg));
1853     DEBUG_MOUNT(Printf("MountDev: Surfaces        %ld\n",vec->de_Surfaces));
1854     DEBUG_MOUNT(Printf("MountDev: SectorsPerBlock %ld\n",vec->de_SectorPerBlock));
1855     DEBUG_MOUNT(Printf("MountDev: BlocksPerTrack  %ld\n",vec->de_BlocksPerTrack));
1856     DEBUG_MOUNT(Printf("MountDev: Reserved        %ld\n",vec->de_Reserved));
1857     DEBUG_MOUNT(Printf("MountDev: PreAlloc        %ld\n",vec->de_PreAlloc));
1858     DEBUG_MOUNT(Printf("MountDev: Interleave      %ld\n",vec->de_Interleave));
1859     DEBUG_MOUNT(Printf("MountDev: LowCyl          %ld\n",vec->de_LowCyl));
1860     DEBUG_MOUNT(Printf("MountDev: UpperCyl        %ld\n",vec->de_HighCyl));
1861     DEBUG_MOUNT(Printf("MountDev: NumBuffers      %ld\n",vec->de_NumBuffers));
1862     DEBUG_MOUNT(if (vec->de_TableSize >= DE_BUFMEMTYPE))
1863     DEBUG_MOUNT(Printf("MountDev: BufMemType      0x%lx\n",vec->de_BufMemType));
1864     DEBUG_MOUNT(Printf("MountDev: MaxTransfer     0x%lx\n",vec->de_MaxTransfer));
1865     DEBUG_MOUNT(if (vec->de_TableSize >= DE_MASK))
1866     DEBUG_MOUNT(Printf("MountDev: Mask            0x%lx\n",vec->de_Mask));
1867     DEBUG_MOUNT(if (vec->de_TableSize >= DE_BOOTPRI))
1868     DEBUG_MOUNT(Printf("MountDev: BootPri         %ld\n",vec->de_BootPri));
1869     DEBUG_MOUNT(if (vec->de_TableSize >= DE_DOSTYPE))
1870     DEBUG_MOUNT(Printf("MountDev: DosType         0x%lx\n",vec->de_DosType));
1871     DEBUG_MOUNT(if (vec->de_TableSize >= DE_BAUD))
1872     DEBUG_MOUNT(Printf("MountDev: Baud            %ld\n",vec->de_Baud));
1873     DEBUG_MOUNT(if (vec->de_TableSize >= DE_CONTROL))
1874     DEBUG_MOUNT(Printf("MountDev: Control         0x%lx\n",vec->de_Control));
1875     DEBUG_MOUNT(if (vec->de_TableSize >= DE_BOOTBLOCKS))
1876     DEBUG_MOUNT(Printf("MountDev: BootBlocks      %ld\n",vec->de_BootBlocks));
1877
1878     if ((dn=MyMakeDosNode(name, IsEHandler ? params : NULL, StartupString)))
1879     {
1880         DEBUG_MOUNT(Printf("MountDev: DeviceNode 0x%lx\n",(ULONG)dn));
1881
1882         dn->dn_StackSize = StackSize;
1883         dn->dn_Priority  = Priority;
1884         dn->dn_GlobalVec = (BPTR)GlobalVec;
1885
1886         if (!IsEHandler && !StartupString)
1887         {
1888             dn->dn_Startup = (BPTR)StartupValue;
1889         }
1890
1891         if (IsFilesystem && ((ForceLoad==0) || (HandlerString==NULL)))
1892         {
1893             DEBUG_MOUNT(Printf("MountDev: patchdosnode\n"));
1894             PatchDosNode(dn,vec->de_DosType);
1895         }
1896
1897         if (ForceLoad || dn->dn_SegList==NULL)
1898         {
1899             DEBUG_MOUNT(Printf("MountDev: Load Handler\n"));
1900             dn->dn_Handler = MKBADDR(HandlerString);
1901         }
1902         else
1903         {
1904             /*
1905              * We don't need the HandlerString anymore...free it
1906              */
1907             if (HandlerString)
1908             {
1909                 FreeVec(HandlerString);
1910                 HandlerString = NULL;
1911             }
1912         }
1913         DEBUG_MOUNT(Printf("MountDev: Name      %b\n",dn->dn_Name));
1914         DEBUG_MOUNT(Printf("MountDev: Handler   0x%lx <%b>\n",dn->dn_Handler,dn->dn_Handler));
1915         DEBUG_MOUNT(Printf("MountDev: SegList   0x%lx\n",dn->dn_SegList));
1916         DEBUG_MOUNT(Printf("MountDev: StackSize %ld\n",dn->dn_StackSize));
1917         DEBUG_MOUNT(Printf("MountDev: Priority  %ld\n",dn->dn_Priority));
1918         if (!IsEHandler && StartupString)
1919         DEBUG_MOUNT(Printf("MountDev: Startup   <%b>\n", dn->dn_Startup));
1920         else
1921         DEBUG_MOUNT(Printf("MountDev: Startup   0x%lx\n",dn->dn_Startup));
1922         DEBUG_MOUNT(Printf("MountDev: GlobalVec %ld\n",dn->dn_GlobalVec));
1923
1924         if (dn->dn_SegList || dn->dn_Handler)
1925         {
1926             if (AddDosEntry((struct DosList *)dn))
1927             {
1928                     DEBUG_MOUNT(Printf("MountDev: AddDosEntry worked\n"));
1929                     /*
1930                      * Don't free these anymore as they belong to the dosnode
1931                      */
1932                     HandlerString = NULL;
1933                     if (IsEHandler)
1934                     {
1935                         UnitString = NULL;
1936                         FlagsString = NULL;
1937                         ControlString = NULL;
1938                     }
1939                     if (Activate)
1940                     {
1941                         DEBUG_MOUNT(Printf("Activating\n"));
1942                         strcat(name, ":");
1943                         DeviceProc(name);
1944                     }
1945                     error = 0;
1946             }
1947             else
1948             {
1949                     DEBUG_MOUNT(Printf("MountDev: AddDosEntry failed\n"));
1950                     error = ERROR_INVALID_RESIDENT_LIBRARY;
1951                     if (HandlerString)
1952                     {
1953                             FreeVec(HandlerString);
1954                     }
1955             }
1956         }
1957         else
1958         {
1959                 DEBUG_MOUNT(Printf("MountDev: no loadseg and no handler specified\n"));
1960                 error = ERROR_OBJECT_NOT_FOUND;
1961         }
1962     }
1963     else
1964     {
1965         error = ERROR_NO_FREE_STORE;
1966     }
1967
1968     return error;
1969 }
1970
1971 void ShowError(char *s, ...)
1972 {
1973         va_list ap;
1974
1975         va_start(ap, s);
1976         if (IsCli)
1977         {
1978                 PutStr("ERROR: ");
1979                 VPrintf(s, ARGS(ap));
1980                 PutStr("\n");
1981         }
1982         else
1983         {
1984                 struct EasyStruct es =
1985                 {
1986                         sizeof(struct EasyStruct),
1987                         0,
1988                         "Mount Failure",
1989                         s,
1990                         "OK"
1991                 };
1992
1993                 IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 36);
1994                 if (IntuitionBase)
1995                 {
1996                         EasyRequestArgs(NULL, &es, NULL, ARGS(ap));
1997                         CloseLibrary((struct Library *)IntuitionBase);
1998                 }
1999         }
2000         va_end(ap);
2001 }
2002
2003 void ShowFault(LONG code, char *s, ...)
2004 {
2005         char buf[256];
2006         va_list ap;
2007         int l;
2008
2009         va_start(ap, s);
2010         l = vsnprintf(buf, sizeof(buf) - 2, s, ap);
2011         va_end(ap);
2012         strcpy(&buf[l], ": ");
2013         l += 2;
2014         Fault(code, NULL, &buf[l], sizeof(buf) - l);
2015         if (IsCli)
2016         {
2017                 PutStr(buf);
2018                 PutStr("\n");
2019         }
2020         else
2021         {
2022                 struct EasyStruct es =
2023                 {
2024                         sizeof(struct EasyStruct),
2025                         0,
2026                         "Mount Failure",
2027                         buf,
2028                         "OK"
2029                 };
2030
2031                 IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 36);
2032                 if (IntuitionBase)
2033                 {
2034                         EasyRequestArgs(NULL, &es, NULL, NULL);
2035                         CloseLibrary((struct Library *)IntuitionBase);
2036                 }
2037         }
2038 }
2039