workbench/c/Mount.c

   1 /*
   2     (C) 1995-2011 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         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 typedef struct Library *UtilityBase_t;
 198 #else
 199 #define PROGNAME "Mount"
 200 typedef struct UtilityBase *UtilityBase_t;
 201 #endif
 202
 203 #ifdef __AROS__
 204 #define _WBenchMsg WBenchMsg
 205 #endif
 206
 207 #ifdef AROS_FAST_BPTR
 208 #define BSTR_EXTRA 1
 209 #define BSTR_OFFSET 0
 210 #define bstrcpy(dest, src, len) strcpy(dest, src)
 211 #else
 212 #define BSTR_EXTRA 2
 213 #define BSTR_OFFSET 1
 214 #define bstrcpy(dest, src, len) \
 215         dest[0] = len; \
 216         strcpy(&dest[1], src);
 217 #endif
 218
 219 static const int __nocommandline;
 220 const TEXT version[] = "\0$VER: " PROGNAME " 50.14 (10.1.2008)";
 221
 222 ULONG CheckDevice(char *name);
 223 void  InitParams(IPTR *params);
 224 LONG  readfile(STRPTR name, STRPTR *mem, LONG *size);
 225 ULONG readmountlist(IPTR *params, STRPTR name, char *mountlist);
 226 ULONG readmountfile(IPTR *params, STRPTR name);
 227 void preparefile(STRPTR buf, LONG size);
 228 LONG parsemountfile(IPTR *params, STRPTR buf, LONG size);
 229 LONG parsemountlist(IPTR *params, STRPTR name, STRPTR buf, LONG size);
 230 LONG mount(IPTR *params, STRPTR name);
 231 void ShowErrorArgs(char *s, IPTR *ap);
 232 void ShowFault(LONG code, char *s, ...);
 233
 234 #define ShowError(s, ...)       \
 235 {                               \
 236     IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
 237     ShowErrorArgs(s, __args);   \
 238 }
 239
 240 struct DosLibrary *DOSBase;
 241 struct IntuitionBase *IntuitionBase;
 242 UtilityBase_t UtilityBase;
 243 struct Process *MyProcess;
 244
 245 ULONG StartupValue;
 246 char *StartupString = NULL;
 247 char *ControlString = NULL;
 248 char *UnitString = NULL;
 249 char *FlagsString = NULL;
 250 ULONG StackSize;
 251 ULONG Priority;
 252 ULONG Activate;
 253 SIPTR GlobalVec;
 254 ULONG ForceLoad;
 255 char *HandlerString;
 256 char *DeviceString;
 257 BOOL  IsEHandler, IsFilesystem;
 258 BOOL  IsCli;
 259 BOOL flagargs[NUM_ARGS];
 260 extern struct WBStartup *_WBenchMsg;
 261
 262 int main(void)
 263 {
 264   IPTR args[2];
 265   IPTR *params;
 266   LONG error = RETURN_FAIL;
 267   struct RDArgs *rda;
 268   char dirname[512];
 269
 270   if ((DOSBase = (struct DosLibrary *)OpenLibrary("dos.library",37))!=0)
 271   {
 272     if ((UtilityBase = (UtilityBase_t)OpenLibrary("utility.library",37)))
 273     {
 274         memset(&flagargs, 0, sizeof(flagargs));
 275         IsEHandler = TRUE;
 276         IsFilesystem = TRUE;
 277         if (!_WBenchMsg)
 278         {
 279           memset(args,0,sizeof(args));
 280           if ((rda = ReadArgs("DEVICE/M,FROM/K", args, NULL)))
 281           {
 282             STRPTR      *MyDevPtr;
 283             int         len;
 284
 285             error = 0;
 286
 287             MyDevPtr    =(STRPTR *)args[0];
 288             if (MyDevPtr)
 289             {
 290               while (*MyDevPtr)
 291               {
 292                 DEBUG_MOUNT(Printf("Mount: Current DevName <%s>\n",
 293                                    (ULONG)*MyDevPtr));
 294
 295                 if ((params = AllocVec(PARAMSLENGTH, MEMF_PUBLIC | MEMF_CLEAR)))
 296                 {
 297                   StackSize     = 8192;
 298                   Priority      = 5;
 299                   GlobalVec     = -1;
 300                   HandlerString = NULL;
 301                   DeviceString  = NULL;
 302                   StartupString = NULL;
 303
 304                   len = strlen(*MyDevPtr);
 305                   if ((*MyDevPtr)[len-1] == ':')
 306                   {
 307                     /* search for a devicename */
 308                     DEBUG_MOUNT(Printf("Mount: search for devname <%s>\n",
 309                                        (ULONG)*MyDevPtr));
 310
 311                     strcpy(dirname, *MyDevPtr);
 312                     dirname[len-1] = '\0';
 313
 314                     if ((error=CheckDevice(dirname))!=RETURN_OK)
 315                     {
 316                       DEBUG_MOUNT(Printf("Mount: is already mounted..stop\n"));
 317                     }
 318                     else
 319                     {
 320                       if (args[1])
 321                       {
 322                         error=readmountlist(params, dirname, (STRPTR)(args[1]));
 323                         DEBUG_MOUNT(Printf("Mount: readmountlist(%s) returned %ld\n", args[1], error));
 324                       }
 325                       else
 326                       {
 327                         char    **SearchPtr;
 328                         ULONG   slen;
 329
 330                         DEBUG_MOUNT(Printf("Mount: search device definition <%s>\n",
 331                                            (ULONG)*MyDevPtr));
 332                         for (SearchPtr=(char**) SearchTable;
 333                              *SearchPtr;
 334                              SearchPtr++)
 335                         {
 336                           if(SetSignal(0L,SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
 337                           {
 338                             error = RETURN_FAIL;
 339                             SetIoErr(ERROR_BREAK);
 340                             break;
 341                           }
 342
 343                           slen = strlen(*SearchPtr);
 344                           strcpy(dirname, *SearchPtr);
 345                           dirname[slen] = '\0';
 346                           strcat(dirname, *MyDevPtr);
 347                           dirname[slen+len-1] = '\0';
 348                           DEBUG_MOUNT(Printf("Mount: try File <%s>\n", (ULONG)dirname));
 349
 350                           error=readmountfile(params, dirname);
 351                           DEBUG_MOUNT(Printf("Mount: readmountfile returned %ld\n", error));
 352                           if (error != ERROR_OBJECT_NOT_FOUND)
 353                             break;
 354                         }
 355                         if (error == ERROR_OBJECT_NOT_FOUND)
 356                         {
 357                           DEBUG_MOUNT(Printf("Mount: try from mountlist\n"));
 358                           dirname[0] = '\0';
 359                           strcat(dirname, *MyDevPtr);
 360                           dirname[len-1] = '\0';
 361                           error=readmountlist(params, dirname, MOUNTLIST);
 362                           DEBUG_MOUNT(Printf("Mount: readmountlist(default) returned %ld\n", error));
 363                         }
 364                       }
 365                     }
 366                   }
 367                   else
 368                   {
 369                     /* search for a filename */
 370
 371                     LONG err;
 372
 373                     UBYTE stack_ap[sizeof(struct AnchorPath) + 3];
 374                     struct AnchorPath   *MyAp = (struct AnchorPath *) (((IPTR) stack_ap + 3) & ~3);
 375
 376                     DEBUG_MOUNT(Printf("Mount: search for mountfile <%s>\n",
 377                                        (ULONG)*MyDevPtr));
 378
 379                     memset(MyAp,0,sizeof(struct AnchorPath));
 380
 381                     dirname[0]  =       '\0';
 382                     for (err = MatchFirst(*MyDevPtr,MyAp);
 383                          err == 0;
 384                          err = MatchNext(MyAp))
 385                     {
 386                       if (MyAp->ap_Flags & APF_DirChanged)
 387                       {
 388                         DEBUG_MOUNT(Printf("Mount: Changed directories...\n"));
 389                       }
 390
 391                       if (NameFromLock(MyAp->ap_Current->an_Lock,
 392                                        dirname,
 393                                        sizeof(dirname)) == FALSE)
 394                       {
 395                         ShowFault(IoErr(), "Error on NameFromLock");
 396                         break;
 397                       }
 398                       if (AddPart(dirname,
 399                                   &(MyAp->ap_Info.fib_FileName[0]),
 400                                   sizeof(dirname)) == FALSE)
 401                       {
 402                         ShowFault(IoErr(), "Error on AddPart");
 403                         break;
 404                       }
 405                       if (MyAp->ap_Info.fib_DirEntryType > 0)
 406                       {
 407                         if (MyAp->ap_Flags & APF_DIDDIR)
 408                         {
 409                           DEBUG_MOUNT(Printf("Mount: Ascending from directory %s\n",
 410                                         (ULONG)dirname));
 411                         }
 412                         else
 413                         {
 414                           DEBUG_MOUNT(Printf("Mount: The next dir is  ... %s\n", (ULONG)dirname));
 415                         }
 416                         /* clear the completed directory flag */
 417                         MyAp->ap_Flags     &=      ~APF_DIDDIR;
 418
 419                       }
 420                       else
 421                       {
 422                         /* Here is code for handling each particular file */
 423
 424                         DEBUG_MOUNT(Printf("Mount: try File <%s>\n",
 425                                            (ULONG)dirname));
 426
 427                         memset(&flagargs, 0, sizeof(flagargs));
 428                         IsEHandler = TRUE;
 429                         IsFilesystem = TRUE;
 430                         error=readmountfile(params, dirname);
 431                         DEBUG_MOUNT(Printf("Mount: readmount file returned %ld\n", error));
 432                       }
 433                     }
 434                     /* This absolutely, positively must be called, all of the time. */
 435                     MatchEnd(MyAp);
 436
 437                     if (err == ERROR_NO_MORE_ENTRIES)
 438                     {
 439                       SetIoErr(0);
 440                     }
 441                     else
 442                     {
 443                       /* if it was real error promote it - Piru */
 444                       error = err;
 445                     }
 446                   }
 447                   FreeVec(params);
 448                 }
 449                 else
 450                 {
 451                   error = ERROR_NO_FREE_STORE;
 452                   break;
 453                 }
 454                 MyDevPtr++;
 455               }
 456             }
 457             FreeArgs(rda);
 458           } /* if (rda != NULL) */
 459           else
 460           {
 461             error = IoErr();
 462           }
 463
 464           if (error && error != ERROR_NO_MORE_ENTRIES && error < ERR_SPECIAL)
 465           {
 466             ShowFault(error, "ERROR");
 467
 468             error = RETURN_FAIL;
 469           }
 470           else
 471           {
 472             error = error < ERR_SPECIAL ? RETURN_OK : RETURN_FAIL;
 473           }
 474
 475         }
 476         else
 477         {
 478           /* wb startup */
 479           if (_WBenchMsg->sm_NumArgs >= 2)
 480           {
 481             if ((params = AllocVec(PARAMSLENGTH,
 482                                    MEMF_PUBLIC | MEMF_CLEAR)))
 483             {
 484               int i;
 485
 486               for (i = 1; i < _WBenchMsg->sm_NumArgs; i++)
 487               {
 488                 BPTR olddir;
 489
 490                 DEBUG_MOUNT(kprintf("Mount: try File <%s>\n",
 491                                    (ULONG) _WBenchMsg->sm_ArgList[i].wa_Name));
 492
 493                 olddir = CurrentDir(_WBenchMsg->sm_ArgList[i].wa_Lock);
 494
 495                 error=readmountfile(params, _WBenchMsg->sm_ArgList[i].wa_Name);
 496                 DEBUG_MOUNT(kprintf("Mount: readmountfile returned %ld\n", error));
 497                 if (error && error != ERROR_NO_MORE_ENTRIES && error < ERR_SPECIAL)
 498                   ShowFault(error, "ERROR");
 499
 500                 (void) CurrentDir(olddir);
 501               }
 502
 503               FreeVec(params);
 504             }
 505             else
 506             {
 507               error = ERROR_NO_FREE_STORE;
 508             }
 509           }
 510         }
 511         CloseLibrary((struct Library *)UtilityBase);
 512     }
 513     CloseLibrary((struct Library *)DOSBase);
 514   }
 515
 516   return error;
 517 }
 518
 519 /************************************************************************************************/
 520 /************************************************************************************************/
 521 ULONG CheckDevice(char *name)
 522 {
 523 struct DosList  *dl;
 524 ULONG           Status;
 525
 526   DEBUG_CHECK(Printf("CheckDevice: <%s>\n",
 527                      name));
 528
 529   dl = LockDosList(LDF_DEVICES | LDF_VOLUMES | LDF_ASSIGNS | LDF_READ);
 530   if ((dl = FindDosEntry(dl,name,LDF_DEVICES | LDF_VOLUMES | LDF_ASSIGNS)))
 531   {
 532     Status      =       ERROR_OBJECT_EXISTS;
 533   }
 534   else
 535   {
 536     Status      =       0;
 537   }
 538   UnLockDosList(LDF_DEVICES | LDF_VOLUMES | LDF_ASSIGNS | LDF_READ);
 539
 540   DEBUG_CHECK(Printf("CheckDevice: object %sexist\n", Status ? "does" : "doesn't "));
 541
 542   return Status;
 543 }
 544
 545 /************************************************************************************************/
 546 /************************************************************************************************/
 547
 548 void InitParams(IPTR *params)
 549 {
 550   struct DosEnvec *vec;
 551
 552   memset(params,0, PARAMSLENGTH);
 553
 554   vec = (struct DosEnvec *)&params[4];
 555
 556   vec->de_TableSize      = DE_BOOTBLOCKS;
 557   vec->de_SizeBlock      = 512 >> 2;
 558   vec->de_Surfaces       = 2;
 559   vec->de_SectorPerBlock = 1;
 560   vec->de_BlocksPerTrack = 11;
 561   vec->de_Reserved       = 2;
 562
 563 /* memset above
 564   vec->de_SecOrg         = 0;
 565   vec->de_BootBlocks     = 0;
 566   vec->de_BootPri        = 0;
 567   vec->de_PreAlloc       = 0;
 568   vec->de_Interleave     = 0;
 569   vec->de_LowCyl         = 0;
 570 */
 571
 572   vec->de_HighCyl        = 79;
 573   vec->de_NumBuffers     = 20;  /* On AmigaOS 3.9 it's 5 */
 574   vec->de_BufMemType     = 3;
 575   vec->de_Baud           = 1200;
 576   vec->de_MaxTransfer    = 0x7fffffff;
 577   vec->de_Mask           = -2;  /* 0xfffffffe, sign-extended on 64 bits */
 578   vec->de_DosType        = ID_DOS_DISK;
 579
 580   StackSize              = 8192;
 581   Priority               = 5;
 582   GlobalVec              = -1;
 583   HandlerString          = NULL;
 584   DeviceString           = NULL;
 585   StartupString          = NULL;
 586 }
 587
 588 void FreeStuff(void)
 589 {
 590   if (UnitString)
 591   {
 592     FreeVec(UnitString);
 593     UnitString = NULL;
 594   }
 595   if (FlagsString)
 596   {
 597     FreeVec(FlagsString);
 598     FlagsString = NULL;
 599   }
 600   if (ControlString)
 601   {
 602     FreeVec(ControlString);
 603     ControlString = NULL;
 604   }
 605   if (HandlerString)
 606   {
 607     FreeVec(HandlerString);
 608     HandlerString = NULL;
 609   }
 610   if (DeviceString)
 611   {
 612     FreeVec(DeviceString);
 613     DeviceString = NULL;
 614   }
 615   if (StartupString)
 616   {
 617     FreeVec(StartupString);
 618     StartupString = NULL;
 619   }
 620 }
 621
 622 /************************************************************************************************/
 623 /************************************************************************************************/
 624
 625 static long GetValue(IPTR bufp, char **end)
 626 {
 627         char *buf = (char *)bufp;
 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         IPTR 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, &args[0], 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] != 0)
 721                 {
 722                         flagargs[i] = TRUE;
 723                 }
 724         }
 725
 726         if (args[ARG_HANDLER] != 0)
 727         {
 728                 s = (STRPTR)args[ARG_HANDLER];
 729                 IsEHandler = FALSE;
 730                 IsFilesystem = FALSE;
 731         }
 732         else if (args[ARG_EHANDLER] != 0)
 733         {
 734                 s = (STRPTR)args[ARG_EHANDLER];
 735                 IsEHandler = TRUE;
 736                 IsFilesystem = FALSE;
 737         }
 738         else if (args[ARG_FILESYSTEM] != 0)
 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] != 0)
 760         {
 761                 StackSize = GetValue(args[ARG_STACKSIZE], NULL);
 762         }
 763
 764         if (args[ARG_PRIORITY] != 0)
 765         {
 766                 Priority = GetValue(args[ARG_PRIORITY], NULL);
 767         }
 768
 769         if (args[ARG_GLOBVEC] != 0)
 770         {
 771                 GlobalVec = GetValue(args[ARG_GLOBVEC], NULL);
 772         }
 773
 774         if (args[ARG_FORCELOAD] != 0)
 775         {
 776                 ForceLoad = GetValue(args[ARG_FORCELOAD], NULL);
 777         }
 778
 779         if (args[ARG_ACTIVATE] != 0)
 780         {
 781                 Activate = GetValue(args[ARG_ACTIVATE], NULL);
 782         }
 783
 784         if (args[ARG_DEVICE] != 0)
 785         {
 786                 int len;
 787
 788                 DEBUG_MOUNT(Printf("ReadMountArgs: Device <%s>\n",(STRPTR)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, (STRPTR)args[ARG_DEVICE]);
 801                 }
 802         }
 803
 804         if (args[ARG_UNIT] != 0)
 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((STRPTR)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, (STRPTR)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] != 0)
 836         {
 837 //                      char *String;
 838
 839                 DEBUG_MOUNT(Printf("ReadMountArgs: Flags <%s>\n",(STRPTR)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((STRPTR)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, (STRPTR)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] != 0)
 883         {
 884                 vec->de_SizeBlock = GetValue(args[ARG_BLOCKSIZE], NULL) >> 2;
 885         }
 886         if (args[ARG_SURFACES] != 0)
 887         {
 888                 vec->de_Surfaces = GetValue(args[ARG_SURFACES], NULL);
 889         }
 890         if (args[ARG_SECTORSPERBLOCK] != 0)
 891         {
 892                 vec->de_SectorPerBlock = GetValue(args[ARG_SECTORSPERBLOCK], NULL);
 893         }
 894         if (args[ARG_BLOCKSPERTRACK] != 0)
 895         {
 896                 vec->de_BlocksPerTrack = GetValue(args[ARG_BLOCKSPERTRACK], NULL);
 897         }
 898         if (args[ARG_RESERVED] != 0)
 899         {
 900                 vec->de_Reserved = GetValue(args[ARG_RESERVED], NULL);
 901         }
 902         if (args[ARG_PREALLOC] != 0)
 903         {
 904                 vec->de_PreAlloc = GetValue(args[ARG_PREALLOC], NULL);
 905         }
 906         if (args[ARG_INTERLEAVE] != 0)
 907         {
 908                 vec->de_Interleave = GetValue(args[ARG_INTERLEAVE], NULL);
 909         }
 910         if (args[ARG_LOWCYL] != 0)
 911         {
 912                 vec->de_LowCyl = GetValue(args[ARG_LOWCYL], NULL);
 913         }
 914         if (args[ARG_HIGHCYL] != 0)
 915         {
 916                 vec->de_HighCyl = GetValue(args[ARG_HIGHCYL], NULL);
 917         }
 918         if (args[ARG_BUFFERS] != 0)
 919         {
 920                 vec->de_NumBuffers = GetValue(args[ARG_BUFFERS], NULL);
 921         }
 922         if (args[ARG_BUFMEMTYPE] != 0)
 923         {
 924                 vec->de_BufMemType = GetValue(args[ARG_BUFMEMTYPE], NULL);
 925         }
 926         if (args[ARG_BOOTPRI] != 0)
 927         {
 928                 vec->de_BootPri = GetValue(args[ARG_BOOTPRI], NULL);
 929         }
 930         if (args[ARG_BAUD] != 0)
 931         {
 932                 vec->de_Baud = GetValue(args[ARG_BAUD], NULL);
 933         }
 934         if (args[ARG_MAXTRANSFER] != 0)
 935         {
 936                 vec->de_MaxTransfer = GetValue(args[ARG_MAXTRANSFER], NULL);
 937         }
 938         if (args[ARG_MASK] != 0)
 939         {
 940                 vec->de_Mask = GetValue(args[ARG_MASK], NULL);
 941         }
 942
 943         if (args[ARG_DOSTYPE] != 0)
 944         {
 945                 vec->de_DosType = (IPTR)GetValue(args[ARG_DOSTYPE], NULL);
 946         }
 947
 948         if (args[ARG_CONTROL] != 0)
 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((STRPTR)args[ARG_CONTROL]);
 958                 if (len < 0x100)
 959                 {
 960                         if ((ControlString=AllocVec(len + BSTR_EXTRA, MEMF_PUBLIC|MEMF_CLEAR)))
 961                         {
 962                                 bstrcpy(ControlString, (STRPTR)args[ARG_CONTROL], len);
 963                                 vec->de_Control = (IPTR)MKBADDR(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] != 0)
 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((STRPTR)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,(STRPTR)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 = (struct FileInfoBlock*)AllocDosObject(DOS_FIB, NULL);
1112       if (fib)
1113       {
1114         if (Examine(lock, fib))
1115         {
1116           nameptr = fib->fib_FileName;
1117           memmove(name, nameptr, strlen(nameptr) + 1);
1118         }
1119         FreeDosObject(DOS_FIB, fib);
1120       }
1121       UnLock(lock);
1122     }
1123     me->pr_WindowPtr = oldwinptr;
1124
1125     if (name[0] == '\0')
1126     {
1127       nameptr           =       FilePart(filename);
1128       strcpy(name,
1129              nameptr);
1130     }
1131   }
1132
1133   DEBUG_MOUNT(Printf("ReadMountFile: mount <%s>\n", (ULONG)name));
1134
1135   if ((error=CheckDevice(name))!=RETURN_OK)
1136   {
1137     return error;
1138   }
1139
1140   InitParams(params);
1141
1142   DEBUG_MOUNT(Printf("ReadMountFile: readfile\n"));
1143
1144   error = readfile(filename,
1145                    &MountListBuf,
1146                    &MountListBufSize);
1147   if (error==RETURN_OK)
1148   {
1149     DEBUG_MOUNT(Printf("ReadMountFile: preparsefile\n"));
1150     preparefile(MountListBuf, MountListBufSize);
1151
1152
1153     DEBUG_MOUNT(Printf("ReadMountFile: parsemountfile\n"));
1154     if ((error = parsemountfile(params, MountListBuf, MountListBufSize))!=RETURN_OK)
1155     {
1156       DEBUG_MOUNT(Printf("ReadMountFile: parsemountfile error %ld\n", error));
1157       ShowFault(IoErr(), "Mountfile '%s' is invalid", filename);
1158     }
1159     else
1160     {
1161       mountinfo =       TRUE;
1162     }
1163     FreeVec(MountListBuf);
1164   }
1165   else
1166   {
1167     DEBUG_MOUNT(Printf("ReadMountFile: mountfile not found..search for <%s.info>\n",
1168                        filename));
1169   }
1170
1171   if ((error==RETURN_OK) ||
1172       (error==ERROR_OBJECT_NOT_FOUND))
1173   {
1174     DEBUG_MOUNT(Printf("ReadMountFile: look for icon\n"));
1175
1176     if ((IconBase =  OpenLibrary("icon.library", 37)))
1177     {
1178       if ((diskobj = GetDiskObject(filename)))
1179       {
1180         myargv  =(char**) diskobj->do_ToolTypes;
1181         if (myargv)
1182         {
1183           while (*myargv)
1184           {
1185             char        *ToolPtr;
1186             ToolPtr     =       *myargv;
1187             DEBUG_MOUNT(Printf("ReadMountFile: ToolType <%s>\n",
1188                                ToolPtr));
1189             if ((ToolPtr[0] != '(') && (ToolPtr[0] != '*') &&
1190                 !((ToolPtr[0] == 'I') && (ToolPtr[1] == 'M') && (ToolPtr[3] == '=')))
1191             {
1192               char      *ToolString;
1193               toollen   =       strlen(ToolPtr);
1194               if ((ToolString = AllocVec(toollen + 2,MEMF_ANY)))
1195               {
1196                 memcpy(ToolString,ToolPtr,toollen);
1197                 ToolString[toollen]     =       '\n';
1198                 ToolString[toollen+1]   =       '\0';
1199                 memset(&rda,0,sizeof(struct RDArgs));
1200                 rda.RDA_Source.CS_Buffer = ToolString;
1201                 rda.RDA_Source.CS_Length = toollen+1;
1202                 rda.RDA_Source.CS_CurChr = 0;
1203                 rda.RDA_Flags = RDAF_NOPROMPT;
1204                 if ((ReadMountArgs(params, &rda)==RETURN_OK))
1205                 {
1206                   mountinfo = TRUE;
1207                 }
1208                 else
1209                 {
1210                   DEBUG_MOUNT(Printf("ReadMountFile: ReadArgs failed error %ld\n",
1211                                      error));
1212                 }
1213                 FreeVec(ToolString);
1214               }
1215               else
1216               {
1217                 error = ERROR_NO_FREE_STORE;
1218                 break;
1219               }
1220             }
1221             else
1222             {
1223               DEBUG_MOUNT(Printf("ReadMountFile: skipped\n"));
1224             }
1225             myargv++;
1226           }
1227         }
1228         FreeDiskObject(diskobj);
1229       }
1230       else
1231       {
1232       }
1233       CloseLibrary(IconBase);
1234     }
1235   }
1236
1237   if (mountinfo)
1238   {
1239     DEBUG_MOUNT(Printf("ReadMountFile: mount information exists\n"));
1240
1241     if ((error = mount(params,name)) != RETURN_OK)
1242     {
1243       DEBUG_MOUNT(Printf("ReadMountFile: mount failed error %ld\n",
1244                          error));
1245     }
1246   }
1247
1248   FreeStuff();
1249
1250   return error;
1251 }
1252
1253 /************************************************************************************************/
1254 /************************************************************************************************/
1255
1256
1257 LONG readfile(STRPTR name, STRPTR *mem, LONG *size)
1258 {
1259     BPTR ml;
1260     ULONG rest,sub;
1261     STRPTR buf;
1262     struct Process *me = (struct Process *) FindTask(NULL);
1263     APTR oldwinptr;
1264
1265     oldwinptr = me->pr_WindowPtr;
1266     me->pr_WindowPtr = (APTR) -1;
1267     ml = Open(name, MODE_OLDFILE);
1268     me->pr_WindowPtr = oldwinptr;
1269
1270     DEBUG_MOUNT(Printf("ReadFile: <%s>\n", (LONG) name));
1271
1272     if (ml)
1273     {
1274         if (Seek(ml, 0, OFFSET_END) != -1)
1275         {
1276             *size = Seek(ml, 0, OFFSET_BEGINNING);
1277
1278             if (*size != -1)
1279             {
1280                 *mem = (STRPTR)AllocVec(*size+2, MEMF_ANY);
1281
1282                 if (*mem)
1283                 {
1284                     rest = *size;
1285                     buf = *mem;
1286
1287                     for (;;)
1288                     {
1289                         if (!rest)
1290                         {
1291                             Close(ml);
1292
1293                             *buf++ = '\n';
1294                             *buf = '\0';
1295
1296                             return 0;
1297                         }
1298
1299                         sub = Read(ml, buf, rest);
1300
1301                         if (sub == -1)
1302                         {
1303                             break;
1304                         }
1305
1306                         rest -= sub;
1307                         buf += sub;
1308                     }
1309
1310                     FreeVec(*mem);
1311                 }
1312                 else
1313                 {
1314                     SetIoErr(ERROR_NO_FREE_STORE);
1315                 }
1316             }
1317         }
1318
1319         Close(ml);
1320     }
1321
1322     DEBUG_MOUNT(Printf("ReadFile: error %ld\n", IoErr()));
1323     return IoErr();
1324 }
1325
1326 /************************************************************************************************/
1327 /************************************************************************************************/
1328
1329
1330 void preparefile(STRPTR buf, LONG size)
1331 {
1332     STRPTR end = buf + size;
1333
1334     while (buf < end)
1335     {
1336         /* Convert comments to spaces */
1337         if (buf + 1 < end && *buf == '/' && buf[1] == '*')
1338         {
1339             *buf++ = ' ';
1340             *buf++ = ' ';
1341
1342             while (buf < end)
1343             {
1344                 if (*buf == '*')
1345                 {
1346                     *buf++ = ' ';
1347
1348                     if (buf >= end)
1349                     {
1350                         break;
1351                     }
1352
1353                     if (*buf == '/')
1354                     {
1355                         *buf++ = ' ';
1356                         break;
1357                     }
1358                 }
1359                 else
1360                 {
1361                     *buf++=' ';
1362                 }
1363             }
1364
1365             continue;
1366         }
1367
1368         /* Skip strings */
1369         if (*buf=='\"')
1370         {
1371             /*
1372              * skip first
1373              */
1374             buf++;
1375             while (buf < end && *buf != '\"')
1376             {
1377                 buf++;
1378             }
1379             /*
1380              * skip last "
1381              */
1382             buf++;
1383             continue;
1384         }
1385
1386         /* Convert '\n' and ';' to spaces */
1387         if (*buf == '\n' || *buf == ';')
1388         {
1389             *buf++ = ' ';
1390             continue;
1391         }
1392
1393         /* Convert '#' to \n */
1394         if (*buf == '#')
1395         {
1396             *buf++ = '\n';
1397             continue;
1398         }
1399
1400         /* Skip all other characters */
1401         buf++;
1402     }
1403 }
1404
1405 /************************************************************************************************/
1406 /************************************************************************************************/
1407
1408 struct FileSysEntry *GetFileSysEntry(ULONG DosType)
1409 {
1410
1411   struct FileSysResource *MyFileSysRes;
1412   struct FileSysEntry *MyFileSysEntry;
1413   struct FileSysEntry *CurrentFileSysEntry;
1414
1415   MyFileSysEntry = NULL;
1416   MyFileSysRes = OpenResource(FSRNAME);
1417   if (MyFileSysRes)
1418   {
1419     Forbid();
1420     CurrentFileSysEntry = (struct FileSysEntry*) MyFileSysRes->fsr_FileSysEntries.lh_Head;
1421     while (CurrentFileSysEntry->fse_Node.ln_Succ)
1422     {
1423       if (CurrentFileSysEntry->fse_DosType == DosType)
1424       {
1425         if (MyFileSysEntry)
1426         {
1427           if (CurrentFileSysEntry->fse_Version > MyFileSysEntry->fse_Version)
1428           {
1429             MyFileSysEntry      =       CurrentFileSysEntry;
1430           }
1431         }
1432         else
1433         {
1434           MyFileSysEntry        =       CurrentFileSysEntry;
1435         }
1436       }
1437       CurrentFileSysEntry       =(struct FileSysEntry*) CurrentFileSysEntry->fse_Node.ln_Succ;
1438     }
1439     Permit();
1440   }
1441   return MyFileSysEntry;
1442 }
1443
1444 /************************************************************************************************/
1445 /************************************************************************************************/
1446
1447 #define PATCH_FIELD(f, name) \
1448     if (MyFileSysEntry->fse_PatchFlags & f) \
1449         MyDeviceNode->dn_ ## name = (typeof(MyDeviceNode->dn_ ## name))MyFileSysEntry->fse_ ## name
1450
1451 void PatchDosNode(struct DeviceNode *MyDeviceNode, ULONG DosType)
1452 {
1453     struct FileSysEntry *MyFileSysEntry;
1454
1455     DEBUG_PATCHDOSNODE(Printf("MakeDosNode: DeviceNode 0x%P\n", MyDeviceNode));
1456
1457     if ((MyFileSysEntry=GetFileSysEntry(DosType)))
1458     {
1459         DEBUG_PATCHDOSNODE(Printf("PatchDosNode: FileSysEntry 0x%P PatchFlags 0x%08lx\n", MyFileSysEntry, MyFileSysEntry->fse_PatchFlags));
1460
1461         PATCH_FIELD(0x0001, Type);
1462         PATCH_FIELD(0x0002, Task);
1463         PATCH_FIELD(0x0004, Lock);
1464         PATCH_FIELD(0x0008, Handler);
1465         PATCH_FIELD(0x0010, StackSize);
1466         PATCH_FIELD(0x0020, Priority);
1467         PATCH_FIELD(0x0040, Startup);
1468         PATCH_FIELD(0x0080, SegList);
1469         PATCH_FIELD(0x0100, GlobalVec);
1470     }
1471     DEBUG_PATCHDOSNODE(else Printf("PatchDosNode: Can't get FileSysEntry..no bootnode\n"));
1472 }
1473
1474
1475 /************************************************************************************************/
1476 /************************************************************************************************/
1477
1478
1479
1480 #define DOSNAME_INDEX    0
1481 #define EXECNAME_INDEX   1
1482 #define UNIT_INDEX       2
1483 #define FLAGS_INDEX      3
1484 #define ENVIROMENT_INDEX 4
1485
1486 struct DeviceNode *MyMakeDosNode(char *DosName, IPTR *ParameterPkt, char *StartupName)
1487 {
1488   int DosNameSize;
1489   int ExecNameSize;
1490   int MyEnvSize = 0;
1491   struct DeviceNode *MyDeviceNode = NULL;
1492   struct FileSysStartupMsg *MyFileSysStartupMsg = NULL;
1493   struct DosEnvec *MyDosEnvec = NULL;
1494   char *MyString = NULL;
1495   ULONG Status = FALSE;
1496   DEBUG_MAKEDOSNODE(Printf("MakeDosNode: Pkt 0x%lx\n",(IPTR)ParameterPkt));
1497
1498   if (ParameterPkt)
1499   {
1500     DEBUG_MAKEDOSNODE(Printf("MakeDosNode: DosName <%s> DeviceName <%s> Unit ", DosName, ParameterPkt[EXECNAME_INDEX]));
1501     DEBUG_MAKEDOSNODE(if (UnitString)
1502                              Printf("<%s>",ParameterPkt[UNIT_INDEX]);
1503                       else
1504                              Printf("%ld",ParameterPkt[UNIT_INDEX]);)
1505     DEBUG_MAKEDOSNODE(Printf(" Flags 0x%lx DE_TABLESIZE 0x%lx\n", ParameterPkt[FLAGS_INDEX], ParameterPkt[ENVIROMENT_INDEX]));
1506   }
1507   else
1508   {
1509     DEBUG_MAKEDOSNODE(Printf("MakeDosNode: DosName <%s> Startup <%s>\n", (IPTR)DosName, (IPTR)StartupName));
1510   }
1511
1512   DosNameSize = strlen(DosName);
1513
1514   if (ParameterPkt)
1515   {
1516     if (ParameterPkt[EXECNAME_INDEX])
1517     {
1518       ExecNameSize = strlen((UBYTE *)ParameterPkt[EXECNAME_INDEX]);
1519     }
1520     else
1521     {
1522       ExecNameSize = 0;
1523     }
1524     MyEnvSize = (ParameterPkt[ENVIROMENT_INDEX] + 1) * sizeof(IPTR);
1525   }
1526   else
1527   {
1528     ExecNameSize = StartupName ? strlen(StartupName) : 0;
1529   }
1530
1531   if ((MyDeviceNode = AllocVec(sizeof(struct DeviceNode), MEMF_PUBLIC | MEMF_CLEAR)))
1532   {
1533     DEBUG_MAKEDOSNODE(Printf("MakeDosNode: MyDeviceNode 0x%lx\n", (ULONG)MyDeviceNode));
1534
1535     MyDeviceNode->dn_StackSize = 600;
1536     MyDeviceNode->dn_Priority  = 10;
1537
1538     if ((MyString=AllocVec(((DosNameSize + BSTR_EXTRA + 4) & ~3) + ((ExecNameSize + BSTR_EXTRA + 4) & ~3), MEMF_PUBLIC | MEMF_CLEAR)))
1539     {
1540       bstrcpy(MyString, DosName, DosNameSize);
1541
1542       MyDeviceNode->dn_Name = MKBADDR(MyString);
1543
1544       if (ParameterPkt)
1545       {
1546         if ((MyFileSysStartupMsg = AllocVec(sizeof(struct FileSysStartupMsg), MEMF_PUBLIC | MEMF_CLEAR)))
1547         {
1548           DEBUG_MAKEDOSNODE(Printf("MakeDosNode: MyFileSysStartupMsg 0x%lx\n", (IPTR)MyFileSysStartupMsg));
1549
1550           if ((MyDosEnvec = AllocVec(MyEnvSize, MEMF_PUBLIC | MEMF_CLEAR)))
1551           {
1552             char *ExecNamePtr;
1553
1554             DEBUG_MAKEDOSNODE(Printf("MakeDosNode: MyDosEnvec 0x%lx\n", (IPTR)MyDosEnvec));
1555             ExecNamePtr = &MyString[(1 + DosNameSize + BSTR_EXTRA + 3) & ~3];
1556
1557             /* .device name must absolutely **NOT** include the 0 in the
1558              * length!!
1559              *
1560              * the string *MUST* be 0 terminated, however!
1561              */
1562             if (ParameterPkt[EXECNAME_INDEX])
1563             {
1564               bstrcpy(ExecNamePtr, (UBYTE *)ParameterPkt[EXECNAME_INDEX], ExecNameSize);
1565             }
1566             else
1567             {
1568               ExecNamePtr[0] = 0;
1569 #ifndef AROS_FAST_BPTR
1570               ExecNamePtr[1] = 0;
1571 #endif
1572             }
1573             MyFileSysStartupMsg->fssm_Device  = MKBADDR(ExecNamePtr);
1574             MyFileSysStartupMsg->fssm_Unit    = ParameterPkt[UNIT_INDEX];
1575             MyFileSysStartupMsg->fssm_Flags   = ParameterPkt[FLAGS_INDEX];
1576             MyFileSysStartupMsg->fssm_Environ = MKBADDR(MyDosEnvec);
1577             MyDeviceNode->dn_Startup          = MKBADDR(MyFileSysStartupMsg);
1578
1579             CopyMem(&ParameterPkt[ENVIROMENT_INDEX], MyDosEnvec, MyEnvSize);
1580
1581             Status=TRUE;
1582             DEBUG_MAKEDOSNODE(Printf("MakeDosNode: done\n"));
1583           }
1584         }
1585       }
1586       else
1587       {
1588         if (StartupName && ExecNameSize)
1589         {
1590           char  *StartupNamePtr;
1591
1592           StartupNamePtr = &MyString[(1 + DosNameSize + BSTR_EXTRA + 3) & ~3];
1593           bstrcpy(StartupNamePtr, StartupName, ExecNameSize);
1594           MyDeviceNode->dn_Startup = MKBADDR(StartupNamePtr);
1595         }
1596         Status=TRUE;
1597       }
1598     }
1599   }
1600   if (Status)
1601   {
1602     DEBUG_MAKEDOSNODE(Printf("MakeDosNode: done\n"));
1603     return MyDeviceNode;
1604   }
1605   else
1606   {
1607     DEBUG_MAKEDOSNODE(Printf("MakeDosNode: failed\n"));
1608     FreeVec(MyFileSysStartupMsg);
1609     FreeVec(MyDeviceNode);
1610     FreeVec(MyString);
1611     return NULL;
1612   }
1613 }
1614
1615
1616
1617 /************************************************************************************************/
1618 /************************************************************************************************/
1619
1620
1621 LONG parsemountfile(IPTR *params, STRPTR buf, LONG size)
1622 {
1623 STRPTR args[NUM_ARGS];
1624 LONG   error;
1625 struct RDArgs rda;
1626
1627     DEBUG_MOUNT(Printf("ParseMountFile:\n"));
1628
1629     memset(&args, 0, sizeof(args));
1630     memset(&rda,0,sizeof(struct RDArgs));
1631
1632     rda.RDA_Source.CS_Buffer = buf;
1633     rda.RDA_Source.CS_Length = size;
1634     rda.RDA_Source.CS_CurChr = 0;
1635     rda.RDA_Flags = RDAF_NOPROMPT;
1636
1637     DEBUG_MOUNT(Printf("ReadArgs..\n%s\n\n",(ULONG)rda.RDA_Source.CS_Buffer));
1638
1639     if ((error=ReadMountArgs(params,
1640                             &rda))!=RETURN_OK)
1641     {
1642         DEBUG_MOUNT(Printf("Parse: ReadArgs failed\n"));
1643     }
1644     return error;
1645 }
1646
1647 /************************************************************************************************/
1648 /************************************************************************************************/
1649
1650
1651 LONG    parsemountlist(IPTR             *params,
1652                        STRPTR           name,
1653                        STRPTR           buf,
1654                        LONG             size)
1655 {
1656 STRPTR args[NUM_ARGS];
1657 UBYTE  buffer[1024];
1658 LONG   error=RETURN_OK, res;
1659 STRPTR end = buf + size;
1660 STRPTR s2;
1661 char *ptr;
1662 struct RDArgs rda;
1663
1664     DEBUG_MOUNT(Printf("ParseMountList: <%s>\n",(ULONG)name));
1665
1666     memset(&args,0,sizeof(args));
1667     memset(&rda,0,sizeof(struct RDArgs));
1668
1669     rda.RDA_Source.CS_Buffer = buf;
1670     rda.RDA_Source.CS_Length = end - buf;
1671     rda.RDA_Source.CS_CurChr = 0;
1672     rda.RDA_Flags = RDAF_NOPROMPT;
1673
1674     while (rda.RDA_Source.CS_CurChr < rda.RDA_Source.CS_Length)
1675     {
1676         res = ReadItem(buffer, sizeof(buffer), &rda.RDA_Source);
1677
1678         DEBUG_MOUNT(Printf("ParseMountList: buffer <%s>\n",(ULONG)buffer));
1679         DEBUG_MOUNT(Printf("ParseMountList: ReadItem res %ld\n",res));
1680
1681         if (res == ITEM_ERROR)
1682         {
1683             return IoErr();
1684         }
1685
1686         if (res == ITEM_NOTHING &&
1687             rda.RDA_Source.CS_CurChr == rda.RDA_Source.CS_Length)
1688         {
1689             return 0;
1690         }
1691
1692         if (res != ITEM_QUOTED && res != ITEM_UNQUOTED)
1693         {
1694             return 1;
1695         }
1696
1697         s2 = buffer;
1698
1699         while (*s2)
1700         {
1701             s2++;
1702         }
1703
1704         if (s2 == buffer || s2[-1] != ':')
1705         {
1706             DEBUG_MOUNT(Printf("ParseMountList: failure\n"));
1707             return ERR_DEVICENOTFOUND;
1708         }
1709
1710         *--s2 = 0;
1711
1712         if (!Strnicmp(name, buffer, s2 - buffer) &&
1713            (!name[s2 - buffer] || (name[s2 - buffer] == ':' || !name[s2 - buffer + 1])))
1714         {
1715             DEBUG_MOUNT(Printf("ParseMountList: found\n"));
1716
1717             /* Copy the string so we get proper case - Piru */
1718             memcpy(name, buffer, s2 - buffer);
1719             name[s2 - buffer] = '\0';
1720
1721             ptr = name;
1722             while (*ptr)
1723             {
1724                 if (*ptr++ == ':')
1725                 {
1726                         ptr[-1] = '\0';
1727                         break;
1728                 }
1729             }
1730
1731             DEBUG_MOUNT(Printf("ReadArgs..\n%s\n\n",(ULONG)&rda.RDA_Source.CS_Buffer[rda.RDA_Source.CS_CurChr]));
1732
1733             if ((error=ReadMountArgs(params,
1734                                      &rda))!=RETURN_OK)
1735             {
1736                 DEBUG_MOUNT(Printf("ParseMountList: ReadArgs failed\n"));
1737                 //return IoErr();
1738             }
1739
1740             return error;
1741         }
1742
1743         while (rda.RDA_Source.CS_CurChr < rda.RDA_Source.CS_Length)
1744         {
1745             if (rda.RDA_Source.CS_Buffer[rda.RDA_Source.CS_CurChr++] == '\n')
1746             {
1747                 DEBUG_MOUNT(Printf("ParseMountList: reach the end of the block\n"));
1748                 break;
1749             }
1750         }
1751     }
1752
1753     DEBUG_MOUNT(Printf("ParseMountList: mount found nothing\n"));
1754     return ERR_DEVICENOTFOUND;
1755 }
1756
1757 /************************************************************************************************/
1758 /************************************************************************************************/
1759
1760 LONG checkmount(IPTR *params)
1761 {
1762 struct DosEnvec *vec;
1763
1764         vec = (struct DosEnvec *)&params[4];
1765
1766         params[1] = (IPTR) DeviceString;
1767
1768         if (IsFilesystem && (!flagargs[ARG_DEVICE]
1769             || !flagargs[ARG_SURFACES] || !flagargs[ARG_BLOCKSPERTRACK]
1770             || !flagargs[ARG_LOWCYL] || !flagargs[ARG_HIGHCYL]))
1771         {
1772                 ShowError("Could not find some of the following keywords:\n"
1773                    "       Surfaces, BlocksPerTrack, LowCyl, HighCyl, Device");
1774                 return ERR_INVALIDKEYWORD;
1775         }
1776         /* bootpri -129 shouldn't be started and not automatic mounted..whatever that means */
1777         if ((vec->de_BootPri < -129) || (vec->de_BootPri > 127))
1778         {
1779             ShowError("BootPri %ld is not allowed. Legal range is -128..127",vec->de_BootPri);
1780             return ERROR_BAD_NUMBER;
1781         }
1782
1783         if (flagargs[ARG_GLOBVEC])
1784         {
1785                 if ((GlobalVec != -1) && (GlobalVec != -2))
1786                 {
1787                     ShowError("Globvec %ld is not supported. Only -1 and -2 are supported here", GlobalVec);
1788                     return ERROR_BAD_NUMBER;
1789                 }
1790         }
1791
1792         if (flagargs[ARG_STARTUP] && !StartupString)
1793         {
1794                 if (StartupValue >= 0x100)
1795                 {
1796                         ShowError("Startup uses a too large numerical number %ld",StartupValue);
1797                         return ERROR_BAD_NUMBER;
1798                 }
1799         }
1800
1801         return RETURN_OK;
1802 }
1803
1804 /************************************************************************************************/
1805 /************************************************************************************************/
1806
1807 LONG mount(IPTR *params, STRPTR name)
1808 {
1809     struct DosEnvec *vec;
1810     LONG error = RETURN_OK;
1811     struct DeviceNode *dn;
1812
1813     strupr(name);
1814     DEBUG_MOUNT(Printf("MountDev: <%s>\n",(ULONG)name));
1815
1816     if ((error=checkmount(params))!=RETURN_OK)
1817     {
1818         DEBUG_MOUNT(Printf("MountDev: checkmount failed\n"));
1819         return error;
1820     }
1821
1822     vec = (struct DosEnvec *)&params[4];
1823
1824     DEBUG_MOUNT(Printf("MountDev: DosName         <%s>\n",(ULONG)name));
1825     DEBUG_MOUNT(Printf("MountDev: Filesystem      <%s>\n",(ULONG)HandlerString + BSTR_OFFSET));
1826     DEBUG_MOUNT(Printf("MountDev: Device          <%s>\n",(ULONG)DeviceString));
1827     DEBUG_MOUNT(Printf("MountDev: TableSize       %ld\n",vec->de_TableSize));
1828     DEBUG_MOUNT(Printf("MountDev: SizeBlock       %ld\n",vec->de_SizeBlock));
1829     DEBUG_MOUNT(Printf("MountDev: SecOrg          %ld\n",vec->de_SecOrg));
1830     DEBUG_MOUNT(Printf("MountDev: Surfaces        %ld\n",vec->de_Surfaces));
1831     DEBUG_MOUNT(Printf("MountDev: SectorsPerBlock %ld\n",vec->de_SectorPerBlock));
1832     DEBUG_MOUNT(Printf("MountDev: BlocksPerTrack  %ld\n",vec->de_BlocksPerTrack));
1833     DEBUG_MOUNT(Printf("MountDev: Reserved        %ld\n",vec->de_Reserved));
1834     DEBUG_MOUNT(Printf("MountDev: PreAlloc        %ld\n",vec->de_PreAlloc));
1835     DEBUG_MOUNT(Printf("MountDev: Interleave      %ld\n",vec->de_Interleave));
1836     DEBUG_MOUNT(Printf("MountDev: LowCyl          %ld\n",vec->de_LowCyl));
1837     DEBUG_MOUNT(Printf("MountDev: UpperCyl        %ld\n",vec->de_HighCyl));
1838     DEBUG_MOUNT(Printf("MountDev: NumBuffers      %ld\n",vec->de_NumBuffers));
1839     DEBUG_MOUNT(if (vec->de_TableSize >= DE_BUFMEMTYPE))
1840     DEBUG_MOUNT(Printf("MountDev: BufMemType      0x%lx\n",vec->de_BufMemType));
1841     DEBUG_MOUNT(Printf("MountDev: MaxTransfer     0x%lx\n",vec->de_MaxTransfer));
1842     DEBUG_MOUNT(if (vec->de_TableSize >= DE_MASK))
1843     DEBUG_MOUNT(Printf("MountDev: Mask            0x%lx\n",vec->de_Mask));
1844     DEBUG_MOUNT(if (vec->de_TableSize >= DE_BOOTPRI))
1845     DEBUG_MOUNT(Printf("MountDev: BootPri         %ld\n",vec->de_BootPri));
1846     DEBUG_MOUNT(if (vec->de_TableSize >= DE_DOSTYPE))
1847     DEBUG_MOUNT(Printf("MountDev: DosType         0x%lx\n",vec->de_DosType));
1848     DEBUG_MOUNT(if (vec->de_TableSize >= DE_BAUD))
1849     DEBUG_MOUNT(Printf("MountDev: Baud            %ld\n",vec->de_Baud));
1850     DEBUG_MOUNT(if (vec->de_TableSize >= DE_CONTROL))
1851     DEBUG_MOUNT(Printf("MountDev: Control         0x%lx\n",vec->de_Control));
1852     DEBUG_MOUNT(if (vec->de_TableSize >= DE_BOOTBLOCKS))
1853     DEBUG_MOUNT(Printf("MountDev: BootBlocks      %ld\n",vec->de_BootBlocks));
1854
1855     if ((dn=MyMakeDosNode(name, IsEHandler ? params : NULL, StartupString)))
1856     {
1857         DEBUG_MOUNT(Printf("MountDev: DeviceNode 0x%lx\n",(ULONG)dn));
1858
1859         dn->dn_StackSize = StackSize;
1860         dn->dn_Priority  = Priority;
1861         dn->dn_GlobalVec = (BPTR)GlobalVec;
1862
1863         if (!IsEHandler && !StartupString)
1864         {
1865             dn->dn_Startup = (BPTR)(SIPTR)StartupValue;
1866         }
1867
1868         if (IsFilesystem && ((ForceLoad==0) || (HandlerString==NULL)))
1869         {
1870             DEBUG_MOUNT(Printf("MountDev: patchdosnode\n"));
1871             PatchDosNode(dn,vec->de_DosType);
1872         }
1873
1874         if (ForceLoad || dn->dn_SegList==BNULL)
1875         {
1876             DEBUG_MOUNT(Printf("MountDev: Load Handler\n"));
1877             dn->dn_Handler = MKBADDR(HandlerString);
1878         }
1879         else
1880         {
1881             /*
1882              * We don't need the HandlerString anymore...free it
1883              */
1884             if (HandlerString)
1885             {
1886                 FreeVec(HandlerString);
1887                 HandlerString = NULL;
1888             }
1889         }
1890         DEBUG_MOUNT(Printf("MountDev: Name      %b\n",dn->dn_Name));
1891         DEBUG_MOUNT(Printf("MountDev: Handler   0x%lx <%b>\n",dn->dn_Handler,dn->dn_Handler));
1892         DEBUG_MOUNT(Printf("MountDev: SegList   0x%lx\n",dn->dn_SegList));
1893         DEBUG_MOUNT(Printf("MountDev: StackSize %ld\n",dn->dn_StackSize));
1894         DEBUG_MOUNT(Printf("MountDev: Priority  %ld\n",dn->dn_Priority));
1895         if (!IsEHandler && StartupString)
1896         DEBUG_MOUNT(Printf("MountDev: Startup   <%b>\n", dn->dn_Startup));
1897         else
1898         DEBUG_MOUNT(Printf("MountDev: Startup   0x%lx\n",dn->dn_Startup));
1899         DEBUG_MOUNT(Printf("MountDev: GlobalVec %ld\n",dn->dn_GlobalVec));
1900
1901         if (dn->dn_SegList || dn->dn_Handler)
1902         {
1903             if (AddDosEntry((struct DosList *)dn))
1904             {
1905                     DEBUG_MOUNT(Printf("MountDev: AddDosEntry worked\n"));
1906                     /*
1907                      * Don't free these anymore as they belong to the dosnode
1908                      */
1909                     HandlerString = NULL;
1910                     if (IsEHandler)
1911                     {
1912                         UnitString = NULL;
1913                         FlagsString = NULL;
1914                         ControlString = NULL;
1915                     }
1916                     if (Activate)
1917                     {
1918                         DEBUG_MOUNT(Printf("Activating\n"));
1919                         strcat(name, ":");
1920                         DeviceProc(name);
1921                     }
1922                     error = 0;
1923             }
1924             else
1925             {
1926                     DEBUG_MOUNT(Printf("MountDev: AddDosEntry failed\n"));
1927                     error = ERROR_INVALID_RESIDENT_LIBRARY;
1928                     if (HandlerString)
1929                     {
1930                             FreeVec(HandlerString);
1931                     }
1932             }
1933         }
1934         else
1935         {
1936                 DEBUG_MOUNT(Printf("MountDev: no loadseg and no handler specified\n"));
1937                 error = ERROR_OBJECT_NOT_FOUND;
1938         }
1939     }
1940     else
1941     {
1942         error = ERROR_NO_FREE_STORE;
1943     }
1944
1945     return error;
1946 }
1947
1948 void ShowErrorArgs(char *s, IPTR *ap)
1949 {
1950         if (IsCli)
1951         {
1952                 PutStr("ERROR: ");
1953                 VPrintf(s, ap);
1954                 PutStr("\n");
1955         }
1956         else
1957         {
1958                 struct EasyStruct es =
1959                 {
1960                         sizeof(struct EasyStruct),
1961                         0,
1962                         "Mount Failure",
1963                         s,
1964                         "OK"
1965                 };
1966
1967                 IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 36);
1968                 if (IntuitionBase)
1969                 {
1970                         EasyRequestArgs(NULL, &es, NULL, ap);
1971                         CloseLibrary((struct Library *)IntuitionBase);
1972                 }
1973         }
1974 }
1975
1976 void ShowFault(LONG code, char *s, ...)
1977 {
1978         char buf[256];
1979         va_list ap;
1980         int l;
1981
1982         va_start(ap, s);
1983         l = vsnprintf(buf, sizeof(buf) - 2, s, ap);
1984         va_end(ap);
1985         strcpy(&buf[l], ": ");
1986         l += 2;
1987         Fault(code, NULL, &buf[l], sizeof(buf) - l);
1988         if (IsCli)
1989         {
1990                 PutStr(buf);
1991                 PutStr("\n");
1992         }
1993         else
1994         {
1995                 struct EasyStruct es =
1996                 {
1997                         sizeof(struct EasyStruct),
1998                         0,
1999                         "Mount Failure",
2000                         buf,
2001                         "OK"
2002                 };
2003
2004                 IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 36);
2005                 if (IntuitionBase)
2006                 {
2007                         EasyRequestArgs(NULL, &es, NULL, NULL);
2008                         CloseLibrary((struct Library *)IntuitionBase);
2009                 }
2010         }
2011 }
2012