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