workbench/devs/rootfs_handler.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: a virtual filesystem that emulates the unixish root dir
   6     Lang: English
   7 */
   8
   9 #define  DEBUG 1
  10 #include <aros/debug.h>
  11
  12 #include <exec/errors.h>
  13 #include <exec/resident.h>
  14 #include <exec/memory.h>
  15 #include <exec/devices.h>
  16 #include <exec/lists.h>
  17 #include <exec/nodes.h>
  18 #include <proto/exec.h>
  19 #include <utility/tagitem.h>
  20 #include <dos/dosextens.h>
  21 #include <dos/filesystem.h>
  22 #include <proto/dos.h>
  23 #include <aros/libcall.h>
  24 #include <aros/asmcall.h>
  25 #if defined(__GNUC__) || defined(__INTEL_COMPILER)
  26 #include "rootfs_handler_gcc.h"
  27 #endif
  28
  29 #include <string.h>
  30 #include <stddef.h>
  31
  32 static const char name[];
  33 static const char version[];
  34 static const APTR inittabl[4];
  35 static void *const functable[];
  36 struct rootfsbase *AROS_SLIB_ENTRY(init,rootfs_handler)();
  37 void AROS_SLIB_ENTRY(open,rootfs_handler)();
  38 BPTR AROS_SLIB_ENTRY(close,rootfs_handler)();
  39 BPTR AROS_SLIB_ENTRY(expunge,rootfs_handler)();
  40 int AROS_SLIB_ENTRY(null,rootfs_handler)();
  41 void AROS_SLIB_ENTRY(beginio,rootfs_handler)();
  42 LONG AROS_SLIB_ENTRY(abortio,rootfs_handler)();
  43
  44 AROS_UFH3(LONG, rootfsproc,
  45     AROS_UFHA(char *,argstr,A0),
  46     AROS_UFHA(ULONG,argsize,D0),
  47     AROS_UFHA(struct ExecBase *,sysbase,A6));
  48
  49 static const char end;
  50
  51 struct root
  52 {
  53     ULONG openfiles;
  54 }
  55
  56 struct filehandle
  57 {
  58     struct root *root;
  59     struct Device *device;
  60     struct Unit *unit;
  61     ULONG  depth;
  62 };
  63
  64 struct rootfsbase
  65 {
  66     struct Device device;
  67     struct ExecBase *sysbase;
  68     struct DosLibrary *dosbase;
  69     struct Process *proc;
  70     BPTR seglist;
  71 };
  72
  73
  74 struct rootmessage
  75 {
  76     struct Message msg;
  77     struct
  78     {
  79         struct IOFileSys newiofs;
  80         struct IOFileSys *oldiofs;
  81     } iofs;
  82 };
  83
  84
  85 int entry(void)
  86 {
  87     /* If the handler was executed by accident return error code. */
  88     return -1;
  89 }
  90
  91 const struct Resident rootfs_handler_resident=
  92 {
  93     RTC_MATCHWORD,
  94     (struct Resident *)&rootfs_handler_resident,
  95     (APTR)&end,
  96     RTF_AUTOINIT,
  97     41,
  98     NT_DEVICE,
  99     0,
 100     (char *)name,
 101     (char *)&version[6],
 102     (ULONG *)inittabl
 103 };
 104
 105 static const char name[]="rootfs.handler";
 106
 107 static const char version[]="$VER: rootfs-handler 41.1 (10.6.2001)\r\n";
 108
 109 static const APTR inittabl[4]=
 110 {
 111     (APTR)sizeof(struct rootfsbase),
 112     (APTR)functable,
 113     NULL,
 114     &AROS_SLIB_ENTRY(init,rootfs_handler)
 115 };
 116
 117 static void *const functable[]=
 118 {
 119     &AROS_SLIB_ENTRY(open,rootfs_handler),
 120     &AROS_SLIB_ENTRY(close,rootfs_handler),
 121     &AROS_SLIB_ENTRY(expunge,rootfs_handler),
 122     &AROS_SLIB_ENTRY(null,rootfs_handler),
 123     &AROS_SLIB_ENTRY(beginio,rootfs_handler),
 124     &AROS_SLIB_ENTRY(abortio,rootfs_handler),
 125     (void *)-1
 126 };
 127
 128 static inline void initIOFS(struct rootfsbase *rootfsbase, struct IOFileSys *iofs,
 129                             ULONG type)
 130 {
 131     struct Process *me = (struct Process *)FindTask(NULL);
 132
 133     iofs->IOFS.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
 134     iofs->IOFS.io_Message.mn_ReplyPort    = &me->pr_MsgPort;
 135     iofs->IOFS.io_Message.mn_Length       = sizeof(struct IOFileSys);
 136     iofs->IOFS.io_Command                 = type;
 137     iofs->IOFS.io_Flags                   = 0;
 138 }
 139
 140 static inline BOOL redirect(struct rootfsbase *rootfsbase, struct IOFileSys *iofs,
 141                      struct Device *device, struct Unit *unit, struct Unit **newunit)
 142 {
 143     struct IOFileSys iofs2;
 144
 145     /* Prepare I/O request. */
 146     initIOFS(rootfsbase, &iofs2, iofs->IOFS.io_Command);
 147
 148     iofs2.IOFS.io_Device = device;
 149     iofs2.IOFS.io_Unit   = unit;
 150
 151     iofs2.io_Union = iofs->io_Union;
 152
 153     kprintf("Sending the request... Device = %s - Unit = %p\n", device->dd_Library.lib_Node.ln_Name, unit);
 154     DoIO(&iofs2.IOFS);
 155     kprintf("Done! Return Code: %d\n", iofs2.io_DosError);
 156     iofs->io_DosError = iofs2.io_DosError;
 157     iofs->io_Union = iofs2.io_Union;
 158
 159     if (newunit)
 160         *newunit = iofs2.IOFS.io_Unit;
 161
 162     return !iofs2.io_DosError;
 163 }
 164
 165 #if 0
 166 static BOOL redirect(struct rootfsbase *rootfsbase, struct IOFileSys *iofs,
 167                      struct Device *device, struct Unit *unit)
 168 {
 169     const struct filehandle *handle = (struct filehandle *)iofs->IOFS.io_Unit;
 170     struct rootmessage *msg;
 171
 172     kprintf(">>>>>>>>>>> In SEND REQUEST <<<<<<<<<\n");
 173
 174     if (namePtr) kprintf("=== name: %s\n", *namePtr);
 175
 176
 177     msg = AllocVec(sizeof(struct rootmessage), MEMF_PUBLIC | MEMF_CLEAR);
 178     if (!msg)
 179     {
 180         iofs->io_DosError = ERROR_NO_FREE_STORE;
 181         return FALSE;
 182     }
 183
 184     kprintf(">>>>>>>>>>> In SEND REQUEST -  2  -  <<<<<<<<<\n");
 185
 186     msg->msg.mn_Length = sizeof(struct rootmessage);
 187
 188     if (iofs)
 189     {
 190         struct FileHandle *fh = (struct FileHandle *)BADDR(handle->lock);
 191         msg->iofs.oldiofs = iofs;
 192         kprintf(">>>>>>>>>>> In SEND REQUEST -  3  -  <<<<<<<<<\n");
 193
 194         if (namePtr)
 195             msg->iofs.newiofs.io_Union.io_NamedFile.io_Filename = *namePtr;
 196         kprintf(">>>>>>>>>>> In SEND REQUEST -  5  -  <<<<<<<<<\n");
 197
 198         iofs->IOFS.io_Flags &= ~IOF_QUICK;
 199         iofs->IOFS.io_Message.mn_Node.ln_Type = NT_MESSAGE;
 200         msg->iofs.newiofs = *iofs;
 201
 202         msg->iofs.newiofs.IOFS.io_Device = fh->fh_Device;
 203         msg->iofs.newiofs.IOFS.io_Unit   = fh->fh_Unit;
 204     }
 205
 206     PutMsg(&(rootfsbase->proc->pr_MsgPort), (struct Message *)msg);
 207
 208     return TRUE;
 209 }
 210 #endif
 211
 212 static STRPTR myStrDup(struct rootfsbase *rootfsbase, STRPTR old)
 213 {
 214     STRPTR new;
 215     int len = strlen(old);
 216
 217     /* Use +2 instead of +1 because we migth want to hold also a ':' */
 218     new = AllocVec(len+2, MEMF_ANY);
 219     if (new)
 220     {
 221         CopyMem(old, new, len);
 222         new[len]='\0';
 223         new[len+1]='\0';
 224     }
 225
 226     return new;
 227 }
 228
 229
 230 static struct filehandle *allocFHandle(struct rootfsbase *rootfsbase, struct root *root,
 231                                        struct Device *device, struct Unit *unit,
 232                                        ULONG depth)
 233 {
 234     struct filehandle *handle = AllocVec(sizeof(struct filehandle), MEMF_ANY);
 235     if (handle)
 236     {
 237         handle->root   = root;
 238         handle->device = device;
 239         handle->unit   = unit;
 240         handle->depth  = depth;
 241         root->openfiles++;
 242     }
 243
 244     return handle;
 245 }
 246
 247 static void freeFHandle(struct rootfsbase *rootfsbase, struct filehandle *handle)
 248 {
 249     handle->root->openfiles--;
 250
 251     FreeVec(handle);
 252 }
 253
 254 static STRPTR skipVol(STRPTR path)
 255 {
 256     STRPTR ptr = path;
 257
 258     while (*ptr != ':' && *ptr != '\0') ptr++;
 259
 260     if (*ptr == ':') path = ptr+1;
 261
 262     return path;
 263 }
 264
 265 static struct filehandle * getFileHandle_1(struct rootfsbase * rootfsbase, struct dnode *curdir,
 266                                            STRPTR path, struct FileInfoBlock *fib,
 267                                            struct IOFileSys *iofs, STRPTR tmp)
 268 {
 269     struct filehandle *handle;
 270     BPTR olddirlock, lock;
 271     STRPTR s1 = path;
 272
 273     kprintf("PATH requested: %s\n", s1);
 274
 275     if (handle->depth == 0 && *path != '/')
 276
 277
 278     while (*path)
 279     {
 280         if (*path == '/')
 281         {
 282             if (depth == 0)
 283             {
 284                 kprintf("OOPS... where the heck do you want to go, huh??\n");
 285                 iofs->io_DosError = ERROR_OBJECT_NOT_FOUND;
 286                 return NULL;
 287             }
 288             kprintf("ascending...\n");
 289
 290             path++;
 291         }
 292         else
 293         {
 294             struct dnode *child;
 295
 296             /* get next part in the path */
 297             for (s1 = path; *s1 != '/' && *s1 != '\0'; s1++);
 298             if (*s1 == '/') *s1++ = '\0';
 299
 300             strcpy(tmp, path);
 301
 302             kprintf("Searching....\n");
 303             for
 304             (
 305                 child = GetHead((struct List *)&curdir->children);
 306                 child ;
 307                 child = GetSucc(child)
 308             )
 309             {
 310                 kprintf("Comparing: %s - %s\n", tmp, child->name);
 311                 if (!strcasecmp(tmp, child->name)) break;
 312             }
 313             kprintf("....Search finished\n");
 314
 315             if (child)
 316             {
 317                 itsadirectory = TRUE;
 318                 itsinthelist  = TRUE;
 319
 320             /* if it's a device add the ':' to the name */
 321             if (!curdir->parent)
 322                 strcat(tmp, ":");
 323
 324
 325             kprintf("Trying to lock '%s'... ", tmp);
 326             olddirlock = CurrentDir(curdir->lock);
 327         lock = Lock(tmp, SHARED_LOCK);
 328         (void)CurrentDir(olddirlock);
 329
 330         if (!lock)
 331         {
 332             kprintf("Failed :(\n", tmp);
 333             iofs->io_DosError = IoErr();
 334             return NULL;
 335         }
 336         kprintf("Succeeded!!\n", tmp);
 337
 338         if (!Examine(lock, fib))
 339         {
 340             int len = strlen(tmp);
 341             /* if Examine() fails assume that the object is a plain file */
 342             fib->fib_DirEntryType = ST_FILE;
 343             if (tmp[len] == ':') tmp[len] = '\0';
 344         }
 345         else
 346         {
 347             strcpy(tmp, fib->fib_FileName);
 348         }
 349
 350         /* A file cannot be in the middle of a path */
 351         if (*s1 && fib->fib_DirEntryType <= 0)
 352         {
 353             kprintf("AHA... what do you want to do, huh?\n");
 354             UnLock(lock);
 355             iofs->io_DosError = ERROR_DIR_NOT_FOUND;
 356             return NULL;
 357         }
 358
 359         /* It's a directory or a device */
 360         if (fib->fib_DirEntryType > 0)
 361         {
 362
 363             if (child)
 364                 curdir = child;
 365             else
 366             {
 367                 curdir = allocDNode(rootfsbase, curdir, tmp, lock);
 368                 if (!curdir)
 369                 {
 370                     UnLock(lock);
 371                     iofs->io_DosError = ERROR_NO_FREE_STORE;
 372                     return NULL;
 373                 }
 374             }
 375         }  /* Is a directory or a device */
 376
 377
 378         /*Is there somthing else in the path? */
 379         if (*s1)
 380         {
 381             kprintf("Recursiiiiiinggggggg......\n");
 382             return getFileHandle_1(rootfsbase, curdir, s1, fib, iofs, tmp);
 383         }
 384
 385         kprintf("Forwarding the request - Current directory is: %S\n", curdir->name);
 386
 387         /* send the request to the proprer device */
 388         {
 389             struct FileHandle *fh = (struct FileHandle *)BADDR(lock);
 390             STRPTR oldfilename = iofs->io_Union.io_OPEN_FILE.io_Filename;
 391             struct Unit   *unit;
 392
 393             iofs->io_Union.io_OPEN_FILE.io_Filename = "";
 394
 395             redirect(rootfsbase, iofs, fh->fh_Device, fh->fh_Unit, &unit);
 396
 397             iofs->io_Union.io_OPEN_FILE.io_Filename = oldfilename;
 398
 399             if (!iofs->io_DosError)
 400             {
 401
 402                 handle = allocFHandle(rootfsbase, curdir, fh->fh_Device, unit);
 403                 if (handle)
 404                 {
 405                     if (lock != curdir->lock)
 406                         UnLock(lock);
 407
 408                     return handle;
 409                 }
 410
 411                 iofs->io_DosError = ERROR_NO_FREE_STORE;
 412
 413                 /* close the file just opened */
 414                 {
 415                     struct IOFileSys dummy;
 416                     dummy.IOFS.io_Command = FSA_CLOSE;
 417                     redirect(rootfsbase, &dummy, fh->fh_Device, fh->fh_Unit, NULL);
 418                 }
 419             }
 420
 421             /* Did we try to open a directory? */
 422             if (lock == curdir->lock)
 423                 freeDNode(rootfsbase, curdir);
 424             else
 425                 UnLock(lock);
 426
 427             //Fault(iofs->io_DosError, "", tmp, MAXFILENAMELENGTH+1);
 428             kprintf("Error trying to open the file: %d", iofs->io_DosError);
 429             return NULL;
 430         }
 431         }
 432     }
 433
 434     kprintf("Ok... this is the end!! %s\n", curdir->name);
 435
 436     if (iofs->IOFS.io_Command == FSA_OPEN)
 437     {
 438         struct FileHandle *fh = (struct FileHandle *)BADDR(curdir->lock);
 439         struct Device *device = fh?fh->fh_Device:NULL;
 440         struct Unit   *unit   = fh?fh->fh_Unit  :NULL;
 441
 442         handle = allocFHandle(rootfsbase, curdir, device, unit);
 443
 444         if (handle)
 445             return handle;
 446
 447         iofs->io_DosError = ERROR_NO_FREE_STORE;
 448     }
 449
 450     if (!iofs->io_DosError)
 451         iofs->io_DosError = ERROR_OBJECT_WRONG_TYPE;
 452
 453     return NULL;
 454 }
 455
 456 static struct filehandle * getFileHandle(struct rootfsbase * rootfsbase, ,
 457                                          STRPTR path, struct IOFileSys *iofs)
 458 {
 459     struct FileInfoBlock *fib = NULL;
 460     UBYTE tmp[MAXFILENAMELENGTH+2];
 461     struct filehandle *handle;
 462
 463     fib = AllocDosObject(DOS_FIB, NULL);
 464     if (!fib)
 465     {
 466         iofs->io_DosError = ERROR_NO_FREE_STORE;
 467         return NULL;
 468     }
 469
 470     handle = getFileHandle_1(rootfsbase, dir, path, fib, iofs, tmp);
 471
 472     FreeDosObject(DOS_FIB, fib);
 473
 474     return handle;
 475 }
 476
 477 static STRPTR getPath(STRPTR path, ULONG *depth)
 478 {
 479     STRPTR ret  = myStrDup(skipVol(path));
 480     STRPTR ret2 = ret;
 481
 482     kprintf("PATH requested: %s\n", path);
 483
 484     if (!ret)
 485     {
 486         *depth = ERROR_NO_FREE_STORE;
 487         return NULL;
 488     }
 489
 490     while (*ret)
 491     {
 492         if (*ret == '/')
 493         {
 494             if (*depth == 0)
 495             {
 496                 *depth = ERROR_OBJECT_NOT_FOUND;
 497                 return NULL;
 498             }
 499             *depth--;
 500             ret++:
 501         }
 502         else
 503         {
 504             for (; *ret != '/' && *ret != '\0'; ret++);
 505             if (*depth == 0)
 506                 *ret = ':';
 507
 508             ret++;
 509         }
 510
 511         *depth++;
 512     }
 513
 514     return ret2;
 515 }
 516
 517 static BOOL open_(struct rootfsbase *rootfsbase, struct IOFileSys *iofs)
 518 {
 519     STRPTR path;
 520     struct filehandle *handle = (struct filehandle *)iofs->IOFS.io_Unit;
 521     ULONG depth = handle->depth;
 522     BOOL redirected = FALSE;
 523     struct
 524     path = getPath(iofs->io_Union.io_OPEN.io_Filename, &depth);
 525
 526     if (path)
 527
 528     getFileHandle(rootfsbase, path, depth, iofs);
 529
 530     if (handle)
 531         (struct filehandle *)iofs->IOFS.io_Unit = handle;
 532
 533     FreeVec(path);
 534
 535     return FALSE;
 536 }
 537
 538 static BOOL close_(struct rootfsbase *rootfsbase, struct IOFileSys *iofs)
 539 {
 540     BOOL redirected = FALSE;
 541
 542     struct filehandle *handle = (struct filehandle *)iofs->IOFS.io_Unit;
 543
 544     /* check we're not the root */
 545     if (handle->depth)
 546     {
 547         kprintf("Closing... Device = %p - Unit = %p\n", handle->device, handle->unit);
 548         redirect(rootfsbase, iofs, handle->device, handle->unit, NULL);
 549     }
 550
 551     kprintf("CLOSE %p\n", iofs->IOFS.io_Unit);
 552
 553     freeFHandle(rootfsbase, handle);
 554
 555     return redirected;
 556
 557 }
 558 #if 0
 559 static BOOL examine(struct rootfsbase *rootfsbase, struct IOFileSys *iofs)
 560 {
 561     struct ExAllData  *ead              = iofs->io_Union.io_EXAMINE.io_ead;
 562     const struct filehandle *handle     = (struct filehandle *)iofs->IOFS.io_Unit;
 563     const ULONG              type       = iofs->io_Union.io_EXAMINE.io_Mode;
 564     const ULONG              size       = iofs->io_Union.io_EXAMINE.io_Size;
 565     STRPTR                   next, end;
 566
 567     static const ULONG sizes[]=
 568     {
 569         0,
 570         offsetof(struct ExAllData,ed_Type),
 571         offsetof(struct ExAllData,ed_Size),
 572         offsetof(struct ExAllData,ed_Prot),
 573         offsetof(struct ExAllData,ed_Days),
 574         offsetof(struct ExAllData,ed_Comment),
 575         offsetof(struct ExAllData,ed_OwnerUID),
 576         sizeof(struct ExAllData)
 577     };
 578
 579     kprintf("In examine...\n");
 580     if (type > ED_OWNER)
 581     {
 582         return ERROR_BAD_NUMBER;
 583     }
 584
 585     next = (STRPTR)ead + sizes[type];
 586     end  = (STRPTR)ead + size;
 587
 588     if(next>end) /* > is correct. Not >= */
 589         return ERROR_BUFFER_OVERFLOW;
 590
 591     iofs->io_DirPos = (LONG)handle->dir;
 592
 593     /* it's not the root */
 594     if (handle->device)
 595     {
 596         /* Get pointer to I/O request. Use stackspace for now. */
 597         kprintf("*NOT* Examining the root\n");
 598         kprintf("Our parent is: %s\n", handle->dir->parent->name);
 599         kprintf("Our dir is: %s\n", handle->dir->name);
 600
 601         redirect(rootfsbase, iofs, handle->device, handle->unit, NULL);
 602
 603         kprintf("Redirection happened...\n");
 604         if (ead->ed_Type == ST_ROOT)
 605             ead->ed_Type = ST_USERDIR;
 606
 607         kprintf("Name: %s - Size: %d - Type: %d\n", ead->ed_Name, ead->ed_Size, ead->ed_Type);
 608     }
 609     else
 610     {
 611     kprintf("*Examining* the root\n");
 612
 613     /* it's the root */
 614     switch(type)
 615     {
 616         case ED_OWNER:
 617             ead->ed_OwnerUID = 0;
 618             ead->ed_OwnerGID = 0;
 619
 620         /* Fall through */
 621         case ED_COMMENT:
 622             ead->ed_Comment = NULL;
 623
 624         /* Fall through */
 625         case ED_DATE:
 626             ead->ed_Days  = 0;
 627             ead->ed_Mins  = 0;
 628             ead->ed_Ticks = 0;
 629
 630         /* Fall through */
 631         case ED_PROTECTION:
 632             ead->ed_Prot = 0;
 633
 634         /* Fall through */
 635         case ED_SIZE:
 636             ead->ed_Size = 0;
 637
 638         /* Fall through */
 639         case ED_TYPE:
 640             ead->ed_Type = ST_ROOT;
 641
 642         /* Fall through */
 643         case ED_NAME:
 644             ead->ed_Name = handle->dir->name;
 645     }
 646     }
 647     ead->ed_Next = (struct ExAllData *)(((IPTR)next + AROS_PTRALIGN - 1) & ~(AROS_PTRALIGN - 1));
 648     kprintf("exiting from examine...\n");
 649     return FALSE;
 650 }
 651 #endif
 652
 653
 654 AROS_UFH3(struct rootfsbase *, AROS_SLIB_ENTRY(init,rootfs_handler),
 655  AROS_UFHA(struct rootfsbase *, rootfsbase, D0),
 656  AROS_UFHA(BPTR,                segList,    A0),
 657  AROS_UFHA(struct ExecBase *,   sysBase, A6)
 658 )
 659 {
 660     AROS_USERFUNC_INIT
 661
 662     /* Store arguments */
 663     rootfsbase->sysbase=sysBase;
 664     rootfsbase->seglist=segList;
 665
 666     rootfsbase->dosbase = (struct DosLibrary *)OpenLibrary("dos.library",39);
 667     if(rootfsbase->dosbase)
 668     {
 669         struct TagItem taglist[]=
 670         {
 671          {NP_Entry,              (IPTR)rootfsproc},
 672          {NP_Name, (IPTR)"rootfs.handler process"},
 673          {NP_UserData,           (IPTR)rootfsbase},
 674          {TAG_DONE,                             0}
 675         };
 676
 677         rootfsbase->proc = CreateNewProc(taglist);
 678
 679         if (rootfsbase->proc)
 680             return rootfsbase;
 681
 682
 683         CloseLibrary((struct Library *)rootfsbase->dosbase);
 684     }
 685
 686     return NULL;
 687     AROS_USERFUNC_EXIT
 688 }
 689
 690 AROS_LH3(void, open,
 691  AROS_LHA(struct IOFileSys *, iofs, A1),
 692  AROS_LHA(ULONG,              unitnum, D0),
 693  AROS_LHA(ULONG,              flags, D1),
 694            struct rootfsbase *, rootfsbase, 1, rootfs_handler)
 695 {
 696     AROS_LIBFUNC_INIT
 697
 698     struct root *root;
 699
 700     /* Get compiler happy */
 701     unitnum=flags=0;
 702
 703    /* Mark Message as recently used. */
 704     iofs->IOFS.io_Message.mn_Node.ln_Type=NT_REPLYMSG;
 705
 706     iofs->IOFS.io_Device=&rootfsbase->device;
 707     iofs->IOFS.io_Error = 0;
 708
 709     root = AllocVec(sizeof(struct root), MEMF_ANY | MEMF_CLEAR);
 710     if (root)
 711     {
 712         struct filehandle *handle;
 713
 714         handle = allocFHandle(rootfsbase, root, NULL, NULL, 0);
 715         if (handle)
 716         {
 717             /* I have one more opener. */
 718             rootfsbase->device.dd_Library.lib_OpenCnt++;
 719             rootfsbase->device.dd_Library.lib_Flags&=~LIBF_DELEXP;
 720             (struct filehandle *)iofs->IOFS.io_Unit = handle;
 721             return;
 722         }
 723
 724         FreeVec(root);
 725     }
 726
 727     iofs->IOFS.io_Error = ERROR_NO_FREE_STORE;
 728     return;
 729
 730     AROS_LIBFUNC_EXIT
 731 }
 732
 733 AROS_LH1(BPTR, close,
 734  AROS_LHA(struct IOFileSys *, iofs, A1),
 735            struct rootfsbase *, rootfsbase, 2, rootfs_handler)
 736 {
 737     AROS_LIBFUNC_INIT
 738     struct filehandle *handle;
 739
 740     handle = (struct filehandle *)iofs->IOFS.io_Unit;
 741
 742     if (handle->device)
 743     {
 744         iofs->io_DosError = ERROR_OBJECT_WRONG_TYPE;
 745         return 0;
 746     }
 747
 748     if (handle->root->opencount)
 749     {
 750         iofs->io_DosError = ERROR_OBJECT_IN_USE;
 751         return 0;
 752     }
 753
 754     freeFHandle(rootfsbase, handle);
 755
 756     /* Let any following attemps to use the device crash hard. */
 757     iofs->IOFS.io_Device=(struct Device *)-1;
 758
 759     iofs->io_DosError=0;
 760
 761     /* I have one fewer opener. */
 762     if(!--rootfsbase->device.dd_Library.lib_OpenCnt)
 763     {
 764         /* Delayed expunge pending? */
 765         if(rootfsbase->device.dd_Library.lib_Flags&LIBF_DELEXP)
 766             /* Then expunge the device */
 767             return expunge();
 768     }
 769     return 0;
 770     AROS_LIBFUNC_EXIT
 771 }
 772
 773 AROS_LH0(BPTR, expunge, struct rootfsbase *, rootfsbase, 3, rootfs_handler)
 774 {
 775     AROS_LIBFUNC_INIT
 776
 777     BPTR ret;
 778     /*
 779         This function is single-threaded by exec by calling Forbid.
 780         Never break the Forbid() or strange things might happen.
 781     */
 782
 783     /* Test for openers. */
 784     if(rootfsbase->device.dd_Library.lib_OpenCnt)
 785     {
 786         /* Set the delayed expunge flag and return. */
 787         rootfsbase->device.dd_Library.lib_Flags|=LIBF_DELEXP;
 788         return 0;
 789     }
 790
 791
 792     /* Tell the helper process to die */
 793     //sendRequest(0, 0);
 794
 795     /* Free all resources */
 796     CloseLibrary((struct Library *)rootfsbase->dosbase);
 797
 798     /* Get rid of the device. Remove it from the list. */
 799     Remove(&rootfsbase->device.dd_Library.lib_Node);
 800
 801     /* Get returncode here - FreeMem() will destroy the field. */
 802     ret=rootfsbase->seglist;
 803
 804     /* Free the memory. */
 805     FreeMem((char *)rootfsbase-rootfsbase->device.dd_Library.lib_NegSize,
 806             rootfsbase->device.dd_Library.lib_NegSize+rootfsbase->device.dd_Library.lib_PosSize);
 807
 808     return ret;
 809     AROS_LIBFUNC_EXIT
 810 }
 811
 812 AROS_LH0I(int, null, struct rootfsbase *, rootfsbase, 4, rootfs_handler)
 813 {
 814     AROS_LIBFUNC_INIT
 815     return 0;
 816     AROS_LIBFUNC_EXIT
 817 }
 818
 819 AROS_LH1(void, beginio,
 820  AROS_LHA(struct IOFileSys *, iofs, A1),
 821            struct rootfsbase *, rootfsbase, 5, rootfs_handler)
 822 {
 823     AROS_LIBFUNC_INIT
 824     BOOL redirected = FALSE;
 825
 826     /*
 827         Do everything quick no matter what. This is possible
 828         because I never need to Wait().
 829     */
 830
 831     kprintf("COMMAND = %d\n", iofs->IOFS.io_Command);
 832     iofs->io_DosError = 0;
 833
 834     switch(iofs->IOFS.io_Command)
 835     {
 836
 837         case FSA_OPEN:
 838         case FSA_OPEN_FILE:
 839             redirected = open_(rootfsbase, iofs);
 840             kprintf("OPEN %p\n", iofs->IOFS.io_Unit);
 841             break;
 842
 843         case FSA_CLOSE:
 844             redirected = close_(rootfsbase, iofs);
 845             break;/*
 846         case FSA_EXAMINE:
 847             redirected = examine(rootfsbase, iofs);
 848             break;  */                    /*
 849         case FSA_EXAMINE_NEXT:          */
 850             /*
 851               Get information about the next object
 852               struct FileInfoBlock *fib;
 853             */           /*
 854             error = examine_next(iofs->io_Union.io_EXAMINE_NEXT.io_fib);
 855                            */
 856         default:
 857             iofs->io_DosError = ERROR_ACTION_NOT_KNOWN;
 858             break;
 859     }
 860
 861     /* If the quick bit is not set send the message to the port */
 862     if(!(iofs->IOFS.io_Flags&IOF_QUICK) && !redirected)
 863     {
 864         kprintf("Che ci faccio qui??\n");
 865         ReplyMsg(&iofs->IOFS.io_Message);
 866     }
 867
 868    AROS_LIBFUNC_EXIT
 869 }
 870
 871 AROS_LH1(LONG, abortio,
 872  AROS_LHA(struct IOFileSys *, iofs, A1),
 873            struct rootfsbase *, rootfsbase, 6, rootfs_handler)
 874 {
 875     AROS_LIBFUNC_INIT
 876     /* Everything already done. */
 877     return 0;
 878     AROS_LIBFUNC_EXIT
 879 }
 880
 881 AROS_UFH3(LONG, rootfsproc,
 882     AROS_UFHA(char *,argstr,A0),
 883     AROS_UFHA(ULONG,argsize,D0),
 884     AROS_UFHA(struct ExecBase *,SysBase,A6))
 885 {
 886     struct Process *me = (struct Process *)FindTask(0);
 887     struct rootmessage *msg;
 888     BOOL cont = TRUE;
 889
 890     do
 891     {
 892         WaitPort(&(me->pr_MsgPort));
 893
 894         while
 895         (
 896             (msg =(struct rootmessage *)GetMsg(&(me->pr_MsgPort))) &&
 897             (cont = (msg->iofs.oldiofs != 0))
 898         )
 899         {
 900             if (msg->msg.mn_Node.ln_Type == NT_REPLYMSG)
 901             {
 902                 struct filehandle *handle;
 903
 904                 msg = ((struct rootmessage *)(((char *)(msg)) - offsetof(struct rootmessage, iofs.newiofs)));
 905
 906                 kprintf("Hurray!! We've received the message back :)\n");
 907
 908                 handle = (struct filehandle *)msg->iofs.oldiofs->IOFS.io_Unit;
 909
 910                 msg->iofs.oldiofs->io_DosError = msg->iofs.newiofs.io_DosError;
 911                 msg->iofs.oldiofs->io_Union    = msg->iofs.newiofs.io_Union;
 912
 913                 ReplyMsg(&(msg->iofs.oldiofs->IOFS.io_Message));
 914                 FreeVec(msg);
 915             }
 916             else
 917             {
 918                 struct filehandle *handle;
 919
 920                 handle = (struct filehandle *)msg->iofs.oldiofs->IOFS.io_Unit;
 921                 kprintf("GOT A MESSAGE: command = %d -\n", msg->iofs.newiofs.IOFS.io_Command);
 922
 923                 msg->iofs.newiofs.IOFS.io_Message.mn_ReplyPort = &(me->pr_MsgPort);
 924
 925                 /* Call BeginIO() vector */
 926                 AROS_LVO_CALL1NR(void,
 927                     AROS_LCA(struct IORequest *,&(msg->iofs.newiofs.IOFS),A1),
 928                     struct Device *, msg->iofs.newiofs.IOFS.io_Device,5,
 929                 );
 930             }
 931         }
 932     } while (cont);
 933
 934     return 0;
 935
 936
 937 }
 938
 939
 940 static const char end=0;