workbench/devs/pipefs_handler.c

   1 /*
   2     Copyright © 1995-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #include <aros/debug.h>
   8
   9 #include <exec/errors.h>
  10 #include <exec/resident.h>
  11 #include <exec/memory.h>
  12 #include <exec/semaphores.h>
  13 #include <exec/lists.h>
  14 #include <exec/nodes.h>
  15 #include <proto/exec.h>
  16 #include <utility/tagitem.h>
  17 #include <dos/dosextens.h>
  18 #include <dos/filesystem.h>
  19 #include <proto/dos.h>
  20 #include <aros/symbolsets.h>
  21 #include <aros/asmcall.h>
  22 #if defined(__GNUC__) || defined(__INTEL_COMPILER)
  23 #include "pipefs_handler_gcc.h"
  24 #endif
  25
  26 #include LC_LIBDEFS_FILE
  27
  28 #include <string.h>
  29 #include <stddef.h>
  30
  31 AROS_UFP3(LONG, pipefsproc,
  32     AROS_UFPA(char *,argstr,A0),
  33     AROS_UFPA(ULONG,argsize,D0),
  34     AROS_UFPA(struct ExecBase *,SysBase,A6));
  35
  36 struct pipefsmessage
  37 {
  38     struct Message    msg;
  39     struct IOFileSys *iofs;
  40     LONG              curlen;
  41 };
  42
  43 struct dirnode
  44 {
  45     struct MinNode   node;
  46     struct dirnode  *parent;     /* Parent directory */
  47     STRPTR           name;
  48     LONG             type;
  49     struct DateStamp datestamp;
  50     ULONG            numusers;
  51     struct List      files;
  52 };
  53
  54 struct filenode
  55 {
  56     struct MinNode   node;
  57     struct dirnode  *parent;
  58     STRPTR           name;
  59     LONG             type;
  60     struct DateStamp datestamp;
  61     ULONG            numusers;           /* Number of actual users of this pipe */
  62     ULONG            numwriters;         /* Num of actual writers */
  63     ULONG            numreaders;         /* Num of actual readers */
  64     struct List      waitinglist;        /* List of files waiting for a reader or a writer to become available */
  65     struct List      pendingwrites;      /* List of pending write requestes */
  66     struct List      pendingreads;       /* List of pending read requestes */
  67     ULONG            flags;              /* See below */
  68 };
  69
  70 /* Flags for filenodes */
  71 #define FNF_DELETEONCLOSE 1               /* Specify this flag when you want a pipe to be deleted
  72                                              when it's closed. Useful for unnamed pipes */
  73 struct usernode
  74 {
  75     struct filenode *fn;
  76     ULONG            mode;
  77 };
  78
  79 static size_t           LenFirstPart (STRPTR path);
  80 static struct filenode *FindFile     (struct pipefsbase *pipefsbase, struct dirnode   **dn_ptr,      STRPTR path);
  81 static struct filenode *GetFile      (struct pipefsbase *pipefsbase, STRPTR filename, struct dirnode *dn, ULONG mode, ULONG *err);
  82 static ULONG            SendRequest  (struct pipefsbase *pipefsbase, struct IOFileSys *iofs, BOOL abort);
  83 static STRPTR           StrDup       (struct pipefsbase *pipefsbase, STRPTR str);
  84
  85
  86 static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR pipefsbase)
  87 {
  88     DOSBase =  (struct DosLibrary *)OpenLibrary("dos.library",39);
  89
  90     if(DOSBase)
  91     {
  92         struct TagItem taglist[]=
  93         {
  94          {NP_Entry,              (IPTR)pipefsproc},
  95          {NP_Name, (IPTR)"pipefs.handler process"},
  96          {NP_UserData,           (IPTR)pipefsbase},
  97          {TAG_DONE,                           0}
  98         };
  99
 100         pipefsbase->proc = CreateNewProc(taglist);
 101
 102         if (pipefsbase->proc)
 103             return TRUE;
 104
 105         CloseLibrary((struct Library *)DOSBase);
 106     }
 107
 108     return FALSE;
 109 }
 110
 111 static int GM_UNIQUENAME(Open)
 112 (
 113     LIBBASETYPEPTR pipefsbase,
 114     struct IOFileSys *iofs,
 115     ULONG unitnum,
 116     ULONG flags
 117 )
 118 {
 119     struct usernode *un;
 120     struct dirnode  *dn;
 121
 122     /* Mark Message as recently used. */
 123     iofs->IOFS.io_Message.mn_Node.ln_Type=NT_REPLYMSG;
 124
 125     /* Build a fake usernode */
 126     un = AllocVec(sizeof(*un),MEMF_PUBLIC|MEMF_CLEAR);
 127     if(un)
 128     {
 129         dn = AllocVec(sizeof(*dn),MEMF_PUBLIC|MEMF_CLEAR);
 130         if (dn)
 131         {
 132             dn->type   = ST_ROOT;
 133             dn->name   = iofs->io_Union.io_OpenDevice.io_DosName;
 134             dn->parent = NULL;
 135
 136             NEWLIST(&dn->files);
 137             DateStamp(&dn->datestamp);
 138
 139             un->fn = (struct filenode *)dn;
 140             iofs->IOFS.io_Unit=(struct Unit *)un;
 141             iofs->IOFS.io_Device=&pipefsbase->device;
 142
 143             iofs->IOFS.io_Error=0;
 144
 145             return TRUE;
 146         }
 147
 148         FreeVec(un);
 149     }
 150
 151     iofs->io_DosError=ERROR_NO_FREE_STORE;
 152
 153     iofs->IOFS.io_Error=IOERR_OPENFAIL;
 154
 155     return FALSE;
 156 }
 157
 158 static int GM_UNIQUENAME(Close)
 159 (
 160     LIBBASETYPEPTR pipefsbase,
 161     struct IOFileSys *iofs
 162 )
 163 {
 164     struct usernode *un;
 165     struct dirnode  *dn;
 166
 167     un = (struct usernode *)iofs->IOFS.io_Unit;
 168     dn = (struct dirnode *)un->fn;
 169
 170     if(!IsListEmpty(&dn->files))
 171     {
 172         iofs->io_DosError=ERROR_OBJECT_IN_USE;
 173         return FALSE;
 174     }
 175
 176     FreeVec(dn);
 177     FreeVec(un);
 178
 179     iofs->io_DosError=0;
 180
 181     return TRUE;
 182 }
 183
 184 static int GM_UNIQUENAME(Expunge)(LIBBASETYPEPTR pipefsbase)
 185 {
 186     /*
 187         This function is single-threaded by exec by calling Forbid.
 188         Never break the Forbid() or strange things might happen.
 189     */
 190
 191     SendRequest(pipefsbase, NULL, TRUE);
 192
 193     /* Free all resources */
 194     CloseLibrary((struct Library *)pipefsbase->dosbase);
 195
 196     return TRUE;
 197 }
 198
 199 AROS_LH1(void, beginio,
 200  AROS_LHA(struct IOFileSys *, iofs, A1),
 201            struct pipefsbase *, pipefsbase, 5, Pipefs)
 202 {
 203     AROS_LIBFUNC_INIT
 204     LONG error=0;
 205     BOOL enqueued = FALSE;
 206
 207     D(bug("COMMAND %d\n", iofs->IOFS.io_Command));
 208     switch(iofs->IOFS.io_Command)
 209     {
 210         case FSA_OPEN:
 211         case FSA_OPEN_FILE:
 212         case FSA_EXAMINE:
 213         case FSA_EXAMINE_NEXT:
 214         case FSA_READ:
 215         case FSA_WRITE:
 216         case FSA_CLOSE:
 217         case FSA_CREATE_DIR:
 218         case FSA_DELETE_OBJECT:
 219         case FSA_FILE_MODE:
 220             error = SendRequest(pipefsbase, iofs, FALSE);
 221             enqueued = !error;
 222             break;
 223
 224         case FSA_SEEK:
 225             error = ERROR_SEEK_ERROR;
 226             break;
 227         case FSA_IS_FILESYSTEM:
 228             iofs->io_Union.io_IS_FILESYSTEM.io_IsFilesystem = TRUE;
 229             break;
 230         case FSA_SET_FILE_SIZE:
 231         case FSA_EXAMINE_ALL:
 232         case FSA_CREATE_HARDLINK:
 233         case FSA_CREATE_SOFTLINK:
 234         case FSA_RENAME:
 235             error = ERROR_NOT_IMPLEMENTED;
 236             break;
 237
 238         default:
 239             error = ERROR_ACTION_NOT_KNOWN;
 240             break;
 241     }
 242
 243     /* Set error code */
 244     iofs->io_DosError=error;
 245
 246     /* If the quick bit is not set and the request hasn't been redirected
 247        send the message to the port
 248     */
 249     if(!(iofs->IOFS.io_Flags&IOF_QUICK) && !enqueued)
 250         ReplyMsg(&iofs->IOFS.io_Message);
 251
 252     AROS_LIBFUNC_EXIT
 253 }
 254
 255 ADD2INITLIB(GM_UNIQUENAME(Init), 0)
 256 ADD2OPENDEV(GM_UNIQUENAME(Open), 0)
 257 ADD2CLOSEDEV(GM_UNIQUENAME(Close), 0)
 258 ADD2EXPUNGELIB(GM_UNIQUENAME(Expunge), 0)
 259
 260 AROS_LH1(LONG, abortio,
 261 AROS_LHA(struct IOFileSys *, iofs, A1),
 262 struct pipefsbase *, pipefsbase, 6, Pipefs)
 263 {
 264     AROS_LIBFUNC_INIT
 265
 266     return SendRequest(pipefsbase, iofs, TRUE);
 267
 268     AROS_LIBFUNC_EXIT
 269 }
 270
 271 static ULONG SendRequest(struct pipefsbase *pipefsbase, struct IOFileSys *iofs, BOOL abort)
 272 {
 273     struct pipefsmessage *msg = AllocVec(sizeof(*msg), MEMF_PUBLIC);
 274
 275     if (msg)
 276     {
 277         msg->msg.mn_Node.ln_Type = NT_MESSAGE;
 278         msg->msg.mn_Node.ln_Name = "PIPEFSMSG";
 279         msg->msg.mn_Length       = sizeof(struct pipefsmessage);
 280         msg->iofs                = iofs;
 281         msg->curlen              = abort;
 282
 283         if (iofs)
 284         {
 285             iofs->IOFS.io_Message.mn_Node.ln_Type = NT_MESSAGE;
 286             iofs->IOFS.io_Flags &= ~IOF_QUICK;
 287         }
 288
 289         PutMsg(&pipefsbase->proc->pr_MsgPort, (struct Message *)msg);
 290
 291         return 0;
 292     }
 293
 294     return ERROR_NO_FREE_STORE;
 295 }
 296
 297 /* The helper process */
 298
 299 #define SendBack(msg, err)                   \
 300 {                                            \
 301     msg->iofs->io_DosError = err;            \
 302     ReplyMsg(&(msg)->iofs->IOFS.io_Message); \
 303     FreeVec(msg);                            \
 304 }
 305
 306 static STRPTR StrDup(struct pipefsbase *pipefsbase, STRPTR str)
 307 {
 308     size_t len = strlen(str)+1;
 309     STRPTR ret = AllocVec(len, MEMF_ANY);
 310
 311     if (ret)
 312         CopyMem(str, ret, len);
 313
 314     return ret;
 315 }
 316
 317 /*
 318   Return the len of the first part in the path.
 319
 320   EXAMPLE
 321     LenFirstPart("yyy/xxx") would return 3
 322     LenFirstPart("xxxx") would return 4
 323 */
 324
 325 static size_t LenFirstPart(STRPTR path)
 326 {
 327     size_t len = 0;
 328
 329     for (; path[0] && path[0] != '/'; path++, len++);
 330
 331     return len;
 332 }
 333
 334 static struct filenode *FindFile(struct pipefsbase *pipefsbase, struct dirnode **dn_ptr, STRPTR path)
 335 {
 336     #define dn (*dn_ptr)
 337
 338     size_t len;
 339     STRPTR nextpart;
 340     struct filenode *fn;
 341
 342     while (path[0] == '/' && dn)
 343     {
 344         dn = dn->parent;
 345         path++;
 346     }
 347
 348     if (!dn) return NULL;
 349
 350     if (!path[0]) return (struct filenode *)dn;
 351
 352     if (dn->type <= 0)
 353     {
 354         D(bug("User wants %S to be a directory, but it's a file.\n", dn->name));
 355         dn = NULL;
 356         return NULL;
 357     }
 358
 359     len      = LenFirstPart(path);
 360     nextpart = &path[len];
 361     fn       = (struct filenode *)GetHead(&dn->files);
 362
 363     D(bug("Searching for %.*S.\n", len, path));
 364
 365     while (fn)
 366     {
 367         D(bug("Comparing %S with %.*S.\n", fn->name, len, path));
 368         if
 369         (
 370             strlen(fn->name) == len               &&
 371             strncasecmp(fn->name, path, len) == 0
 372         )
 373         {
 374             break;
 375         }
 376         fn = (struct filenode *)GetSucc((struct Node *)fn);
 377     }
 378
 379     if (fn)
 380     {
 381         if (nextpart[0] == '/') nextpart++;
 382
 383         dn = (struct dirnode *)fn;
 384         fn = FindFile(pipefsbase, &dn, nextpart);
 385     }
 386
 387     return fn;
 388
 389     #undef dn
 390 }
 391
 392 static struct filenode *NewFileNode(struct pipefsbase *pipefsbase, STRPTR filename, ULONG flags, struct dirnode *dn, ULONG *err)
 393 {
 394     struct filenode *fn;
 395
 396     fn = AllocVec(sizeof(*fn), MEMF_PUBLIC|MEMF_CLEAR);
 397     if (fn)
 398     {
 399         fn->name = StrDup(pipefsbase, filename);
 400
 401         if (fn->name)
 402         {
 403             fn->type = ST_PIPEFILE;
 404
 405             DateStamp(&fn->datestamp);
 406             NEWLIST(&fn->waitinglist);
 407             NEWLIST(&fn->pendingwrites);
 408             NEWLIST(&fn->pendingreads);
 409
 410             fn->parent = dn;
 411             fn->flags  = flags;
 412
 413             AddTail(&dn->files, (struct Node *)fn);
 414             D(bug("New file created and added to the list\n"));
 415
 416             return fn;
 417         }
 418
 419         FreeVec(fn);
 420     }
 421
 422     D(bug("AllocVec Failed. No more memory available\n"));
 423     *err = ERROR_NO_FREE_STORE;
 424     return NULL;
 425 }
 426
 427 static struct filenode *GetFile(struct pipefsbase *pipefsbase, STRPTR filename, struct dirnode *dn, ULONG mode, ULONG *err)
 428 {
 429     struct filenode *fn;
 430
 431     D(bug("User wants to open file %S.\n", filename));
 432     D(bug("Current directory is %S\n", dn->name));
 433
 434     if (dn && !dn->parent && strcmp(filename, "__UNNAMED__") == 0)
 435     {
 436         return NewFileNode(pipefsbase, "__UNNAMED__", FNF_DELETEONCLOSE, dn, err);
 437     }
 438
 439     fn = FindFile(pipefsbase, &dn, filename);
 440     if (!fn)
 441     {
 442         D(bug("The file couldn't be found.\n"));
 443
 444         if (dn && mode&FMF_CREATE)
 445         {
 446             D(bug("But the user wants it to be created.\n"));
 447
 448             return NewFileNode(pipefsbase, FilePart(filename), 0, dn, err);
 449         }
 450         else
 451         {
 452             *err = ERROR_OBJECT_NOT_FOUND;
 453         }
 454     }
 455
 456     if (fn && fn->type > 0 && mode&(FMF_WRITE|FMF_READ))
 457     {
 458         D(bug("The file is a directory, cannot be open for reading/writing\n"));
 459         *err = ERROR_OBJECT_WRONG_TYPE;
 460         return NULL;
 461     }
 462
 463     return fn;
 464 }
 465
 466 #undef SysBase
 467 #ifndef kprintf
 468      struct ExecBase *SysBase;
 469 #else
 470 #    define SysBase _SysBase
 471 #endif
 472
 473
 474 AROS_UFH3(LONG, pipefsproc,
 475     AROS_UFHA(char *,argstr,A0),
 476     AROS_UFHA(ULONG,argsize,D0),
 477     AROS_UFHA(struct ExecBase *,_SysBase,A6))
 478 {
 479     AROS_USERFUNC_INIT
 480
 481     struct Process       *me;
 482     struct pipefsbase    *pipefsbase;
 483     struct pipefsmessage *msg;
 484     struct usernode      *un;
 485     struct filenode      *fn;
 486     BOOL cont = TRUE;
 487
 488     SysBase = _SysBase;
 489
 490     me         = (struct Process *)FindTask(0);
 491     pipefsbase = me->pr_Task.tc_UserData;
 492
 493
 494     do
 495     {
 496         WaitPort(&(me->pr_MsgPort));
 497
 498         while
 499         (
 500             (msg =(struct pipefsmessage *)GetMsg(&(me->pr_MsgPort))) &&
 501             (cont = (msg->iofs != 0))
 502         )
 503         {
 504             D(bug("Message received.\n"));
 505
 506             un = (struct usernode *)msg->iofs->IOFS.io_Unit;
 507             fn = un->fn;
 508
 509             if (msg->curlen) /* This field is abused too see whethet the user wants to abort the request */
 510             {
 511                 struct pipefsmessage *msg2;
 512                 BOOL found = FALSE;
 513
 514                 D(bug("The user wants to abort this request.\n"));
 515
 516                 ForeachNode(&fn->waitinglist, msg2)
 517                 {
 518                     if (msg2->iofs == msg->iofs)
 519                     {
 520                         found = TRUE;
 521
 522                         fn->numusers--;
 523                         if (un->mode & FMF_WRITE)
 524                             fn->numwriters--;
 525                         if (un->mode & FMF_READ)
 526                             fn->numreaders--;
 527
 528                         FreeVec(un);
 529
 530                         break;
 531                     }
 532                 }
 533                 if (!found && (un->mode & FMF_WRITE))
 534                 {
 535                     ForeachNode(&fn->pendingwrites, msg2)
 536                     {
 537                         if (msg2->iofs == msg->iofs)
 538                         {
 539                             found = TRUE;
 540                             break;
 541                         }
 542                     }
 543                 }
 544                 if (!found && (un->mode & FMF_READ))
 545                 {
 546                     ForeachNode(&fn->pendingreads, msg2)
 547                     {
 548                         if (msg2->iofs == msg->iofs)
 549                         {
 550                             found = TRUE;
 551                             break;
 552                         }
 553                     }
 554                 }
 555
 556                 if (found)
 557                 {
 558                     D(bug("Aborting the request.\n"));
 559                     Remove((struct Node *)msg2);
 560                     msg2->iofs->IOFS.io_Error = IOERR_ABORTED;
 561                     SendBack(msg2, ERROR_INTERRUPTED);
 562                 }
 563                 else
 564                 {
 565                     D(bug("There was no I/O in process for this request.\n"));
 566                 }
 567
 568                 FreeVec(msg);
 569                 continue;
 570             }
 571
 572             switch (msg->iofs->IOFS.io_Command)
 573             {
 574                 case FSA_OPEN:
 575                     msg->iofs->io_Union.io_OPEN.io_FileMode &= ~(FMF_WRITE|FMF_READ);
 576                     /* Fall through */
 577                 case FSA_OPEN_FILE:
 578                 {
 579                     struct usernode *un;
 580                     BOOL             stillwaiting;
 581                     ULONG            err;
 582
 583                     D(bug("Command is OPEN\n"));
 584
 585                     /*
 586                        I would have liked to put this AFTER GetFile(),
 587                        but then it would have been really difficult to
 588                        undo what's done in GetFile() if the following AllocVec()
 589                        failed...
 590                     */
 591                     un = AllocVec(sizeof(*un), MEMF_PUBLIC);
 592                     if (!un)
 593                     {
 594                         SendBack(msg, ERROR_NO_FREE_STORE);
 595                         continue;
 596                     }
 597
 598                     un->mode = msg->iofs->io_Union.io_OPEN.io_FileMode;
 599
 600                     fn = GetFile(pipefsbase, msg->iofs->io_Union.io_OPEN.io_Filename, (struct dirnode *)fn, un->mode, &err);
 601                     if (!fn)
 602                     {
 603                         FreeVec(un);
 604                         SendBack(msg, err);
 605                         continue;
 606                     }
 607
 608                     D(bug("File requested found.\n"));
 609                     D(bug("The requested file is %s.\n",
 610                             fn->type <= 0  ?
 611                             "a pipe":
 612                             "a directory"));
 613
 614                     msg->iofs->IOFS.io_Unit = (struct Unit *)un;
 615                     fn->numusers++;
 616                     un->fn = fn;
 617
 618                     if (fn->type > 0)
 619                     {
 620                         SendBack(msg, 0);
 621                         continue;
 622                     }
 623
 624                     stillwaiting = !fn->numwriters || !fn->numreaders;
 625
 626                     if (un->mode == FMF_MODE_OLDFILE) un->mode &= ~FMF_WRITE;
 627                     if (un->mode == FMF_MODE_NEWFILE) un->mode &= ~FMF_READ;
 628
 629                     if (un->mode & FMF_READ)
 630                     {
 631                         D(bug("User wants to read. "));
 632                         fn->numreaders++;
 633                     }
 634                     if (un->mode & FMF_WRITE)
 635                     {
 636                         D(bug("User wants to write. "));
 637                         fn->numwriters++;
 638                     }
 639
 640                     D(bug("There are %d readers and %d writers at the moment\n", fn->numreaders, fn->numwriters));
 641
 642                     if (!fn->numwriters || !fn->numreaders)
 643                     {
 644                         if (un->mode&(FMF_WRITE|FMF_READ) && !(un->mode&FMF_NONBLOCK))
 645                         {
 646                             /*
 647                                If we're lacking of writers or readers
 648                                then add this message to a waiting list.
 649                             */
 650                             D(bug("There are no %s at the moment, so this %s must wait\n",
 651                                      fn->numwriters?"readers":"writers",
 652                                      fn->numwriters?"writer":"reader"));
 653
 654                             AddTail(&fn->waitinglist, (struct Node *)msg);
 655                         }
 656                         else
 657                             SendBack(msg, 0);
 658                     }
 659                     else
 660                     {
 661                         if (stillwaiting)
 662                         {
 663                             /*
 664                               Else wake up all the ones that were still waiting
 665                             */
 666                             struct pipefsmessage *msg;
 667
 668                             D(bug("Finally there are enough readers and writers! "
 669                                     "Wake up all of them\n"));
 670
 671                             while ((msg = (struct pipefsmessage *)RemHead(&fn->waitinglist)))
 672                                 SendBack(msg, 0);
 673                         }
 674                         SendBack(msg, 0);
 675                     }
 676
 677                     continue;
 678                 }
 679                 case FSA_CLOSE:
 680                     D(bug("Command is FSA_CLOSE\n"));
 681
 682                     if (un->mode & FMF_READ)
 683                     {
 684                         D(bug("User was a reader. "));
 685                         fn->numreaders--;
 686                         D(bug("There are %d readers at the moment\n", fn->numreaders));
 687                         if (!fn->numreaders)
 688                         {
 689                             struct pipefsmessage *msg;
 690
 691                             D(bug("There are no readers anymore. %s\n",
 692                                     IsListEmpty(&fn->pendingwrites) ?
 693                                     "There are no pending writes"   :
 694                                     "Reply to all the waiting writers"));
 695
 696                             while ((msg = (struct pipefsmessage *)RemHead(&fn->pendingwrites)))
 697                                 SendBack(msg, 0);
 698                         }
 699                     }
 700                     if (un->mode & FMF_WRITE)
 701                     {
 702                         D(bug("User was a writer. "));
 703                         fn->numwriters--;
 704                         D(bug("There are %d writers at the moment\n", fn->numwriters));
 705
 706                         if (!fn->numwriters)
 707                         {
 708                             struct pipefsmessage *msg;
 709
 710                             D(bug("There are no writers anymore. %s\n",
 711                                     IsListEmpty(&fn->pendingreads) ?
 712                                     "There are no pending reads"   :
 713                                     "Reply to all the waiting readers"));
 714                             while ((msg = (struct pipefsmessage *)RemHead(&fn->pendingreads)))
 715                             {
 716                                 msg->iofs->io_Union.io_READ_WRITE.io_Length =
 717                                 msg->iofs->io_Union.io_READ_WRITE.io_Length - msg->curlen;
 718                                 SendBack(msg, 0);
 719                             }
 720                         }
 721                     }
 722
 723                     un->fn->numusers--;
 724
 725                     if (!un->fn->numusers && un->fn->type <= 0 && (un->fn->flags & FNF_DELETEONCLOSE))
 726                     {
 727                         Remove((struct Node *)fn);
 728                         FreeVec(fn->name);
 729                         FreeVec(fn);
 730                     }
 731
 732                     FreeVec(un);
 733                     SendBack(msg, 0);
 734
 735                     continue;
 736                 case FSA_EXAMINE:
 737                 {
 738                     struct ExAllData  *ead        = msg->iofs->io_Union.io_EXAMINE.io_ead;
 739                     const ULONG        type       = msg->iofs->io_Union.io_EXAMINE.io_Mode;
 740                     const ULONG        size       = msg->iofs->io_Union.io_EXAMINE.io_Size;
 741                     STRPTR             next, end;
 742
 743                     static const ULONG sizes[]=
 744                     {
 745                         0,
 746                         offsetof(struct ExAllData,ed_Type),
 747                         offsetof(struct ExAllData,ed_Size),
 748                         offsetof(struct ExAllData,ed_Prot),
 749                         offsetof(struct ExAllData,ed_Days),
 750                         offsetof(struct ExAllData,ed_Comment),
 751                         offsetof(struct ExAllData,ed_OwnerUID),
 752                         sizeof(struct ExAllData)
 753                     };
 754
 755                     D(bug("Command is EXAMINE\n"));
 756                     D(bug("Examining file %S\n", fn->name));
 757
 758                     if (type > ED_OWNER)
 759                     {
 760                         D(bug("The user requested an invalid type\n"));
 761                         SendBack(msg, ERROR_BAD_NUMBER);
 762                         continue;
 763                     }
 764
 765                     next = (STRPTR)ead + sizes[type];
 766                     end  = (STRPTR)ead + size;
 767
 768                     if(next>end)  /* > is correct. Not >= */
 769                     {
 770                         SendBack(msg, ERROR_BUFFER_OVERFLOW);
 771                         continue;
 772                     }
 773
 774                     if (fn->type > 0)
 775                     {
 776                         msg->iofs->io_DirPos = (LONG)GetHead(&((struct dirnode *)fn)->files);
 777                     }
 778                     else
 779                     {
 780                         msg->iofs->io_DirPos = (LONG)fn;
 781                     }
 782
 783                     switch(type)
 784                     {
 785                         case ED_OWNER:
 786                         ead->ed_OwnerUID = 0;
 787                         ead->ed_OwnerGID = 0;
 788
 789                         /* Fall through */
 790                         case ED_COMMENT:
 791                             ead->ed_Comment = NULL;
 792
 793                         /* Fall through */
 794                         case ED_DATE:
 795                             ead->ed_Days  = fn->datestamp.ds_Days;
 796                             ead->ed_Mins  = fn->datestamp.ds_Minute;
 797                             ead->ed_Ticks = fn->datestamp.ds_Tick;
 798
 799                         /* Fall through */
 800                         case ED_PROTECTION:
 801                             ead->ed_Prot = 0;
 802
 803                         /* Fall through */
 804                         case ED_SIZE:
 805                             ead->ed_Size = 0;
 806
 807                         /* Fall through */
 808                         case ED_TYPE:
 809                             ead->ed_Type = fn->type;
 810
 811                         /* Fall through */
 812                         case ED_NAME:
 813                         {
 814                             STRPTR name = fn->name;
 815                             ead->ed_Name = next;
 816
 817                             for (;;)
 818                             {
 819                                 if (next >= end)
 820                                 {
 821                                     SendBack(msg, ERROR_BUFFER_OVERFLOW);
 822                                     continue;
 823                                 }
 824
 825                                 if (!(*next++ = *name++))
 826                                 {
 827                                     break;
 828                                 }
 829                             }
 830                         }
 831                     }
 832
 833                     ead->ed_Next = (struct ExAllData *)(((IPTR)next + AROS_PTRALIGN - 1) & ~(AROS_PTRALIGN - 1));
 834
 835                     SendBack(msg, 0);
 836                     continue;
 837                 }
 838                 case FSA_EXAMINE_NEXT:
 839                 {
 840                     struct FileInfoBlock *fib = msg->iofs->io_Union.io_EXAMINE_NEXT.io_fib;
 841                     struct filenode      *fn  = (struct filenode *)fib->fib_DiskKey;
 842
 843                     D(bug("Command is EXAMINE_NEXT\n"));
 844
 845                     if (!fn)
 846                     {
 847                         D(bug("There are no more entries in this directory\n"));
 848                         SendBack(msg, ERROR_NO_MORE_ENTRIES);
 849                         continue;
 850                     }
 851
 852                     D(bug("Current directory is %S. Current file is %S\n", fn->parent->name, fn->name));
 853
 854                     fib->fib_OwnerUID       = 0;
 855                     fib->fib_OwnerGID       = 0;
 856                     fib->fib_Date.ds_Days   = fn->datestamp.ds_Days;
 857                     fib->fib_Date.ds_Minute = fn->datestamp.ds_Minute;
 858                     fib->fib_Date.ds_Tick   = fn->datestamp.ds_Tick;
 859                     fib->fib_Protection     = 0;
 860                     fib->fib_Size           = 0;
 861                     fib->fib_DirEntryType   = fn->type;
 862
 863                     strncpy(fib->fib_FileName, fn->name, MAXFILENAMELENGTH - 1);
 864                     fib->fib_Comment[0] = '\0';
 865
 866                     fib->fib_DiskKey = (LONG)GetSucc(fn);
 867                     SendBack(msg, 0);
 868
 869                     continue;
 870                 }
 871                 case FSA_CREATE_DIR:
 872                 {
 873                     STRPTR filename        = msg->iofs->io_Union.io_CREATE_DIR.io_Filename;
 874                     struct dirnode *parent = (struct dirnode *)fn;
 875                     struct dirnode *dn;
 876
 877                     D(bug("Command is FSA_CREATE_DIR\n"));
 878                     D(bug("Current directory is %S\n", parent->name));
 879                     D(bug("User wants to create directory %S\n", filename));
 880
 881                     dn = (struct dirnode *)FindFile(pipefsbase, &parent, filename);
 882                     if (dn)
 883                     {
 884                         D(bug("The object %S already exists\n", filename));
 885                         SendBack(msg, ERROR_OBJECT_EXISTS);
 886                         continue;
 887                     }
 888                     else
 889                     if (!parent)
 890                     {
 891                         D(bug("The path is not valid.\n"));
 892                         SendBack(msg, ERROR_OBJECT_NOT_FOUND);
 893                         continue;
 894                     }
 895
 896                     if
 897                     (
 898                         !(un       = AllocVec(sizeof(*un), MEMF_PUBLIC)) ||
 899                         !(dn       = AllocVec(sizeof(*dn), MEMF_PUBLIC)) ||
 900                         !(dn->name = StrDup(pipefsbase, filename))
 901                     )
 902                     {
 903                         SendBack(msg, ERROR_NO_FREE_STORE);
 904                         continue;
 905                     }
 906
 907                     D(bug("Ok, there's room for this directory.\n"));
 908                     AddTail(&parent->files, (struct Node *)dn);
 909                     dn->parent   = parent;
 910                     dn->numusers = 0;
 911                     dn->type     = ST_USERDIR;
 912                     NEWLIST(&dn->files);
 913                     DateStamp(&dn->datestamp);
 914
 915                     un->fn   = (struct filenode *)dn;
 916                     un->mode = 0;
 917                     msg->iofs->IOFS.io_Unit = (struct Unit *)un;
 918
 919                     SendBack(msg, 0);
 920                     continue;
 921                 }
 922                 case FSA_FILE_MODE:
 923                     D(bug("Command is FSA_FILE_MODE\n"));
 924                     D(bug("Current mode is 0x%08x\n", un->mode));
 925
 926                     un->mode &= ~msg->iofs->io_Union.io_FILE_MODE.io_Mask;
 927                     un->mode |= msg->iofs->io_Union.io_FILE_MODE.io_FileMode;
 928
 929                     D(bug("New mode is 0x%08x\n", un->mode));
 930
 931                     SendBack(msg, 0);
 932                     continue;
 933                 case FSA_DELETE_OBJECT:
 934                 {
 935                     STRPTR filename    = msg->iofs->io_Union.io_DELETE_OBJECT.io_Filename;
 936                     struct dirnode *dn = (struct dirnode *)fn;
 937
 938                     D(bug("Command is FSA_DELETE_OBJECT\n"));
 939                     D(bug("Current directory is %S\n", fn->name));
 940                     D(bug("User wants to delete the object %S\n", filename));
 941
 942                     fn = FindFile(pipefsbase, &dn, filename);
 943                     if (!fn)
 944                     {
 945                         D(bug("The object doesn't exist\n"));
 946                         SendBack(msg, ERROR_OBJECT_NOT_FOUND);
 947                         continue;
 948                     }
 949                     if (fn->type == ST_ROOT)
 950                     {
 951                         D(bug("The object is the root directory. Cannot be deleted\n"));
 952                         SendBack(msg, ERROR_OBJECT_WRONG_TYPE);
 953                         continue;
 954                     }
 955                     if (fn->numusers)
 956                     {
 957                         D(bug("The object is in use, cannot be deleted\n"));
 958                         SendBack(msg, ERROR_OBJECT_IN_USE);
 959                         continue;
 960                     }
 961                     if (fn->type > 0 && !IsListEmpty(&((struct dirnode *)fn)->files))
 962                     {
 963                         D(bug("The object is a directory, but is not empty, thus cannot be deleted\n"));
 964                         SendBack(msg, ERROR_DIRECTORY_NOT_EMPTY);
 965                         continue;
 966                     }
 967
 968                     D(bug("Removing the object from it's parent directory\n"));
 969
 970                     Remove((struct Node *)fn);
 971                     FreeVec(fn->name);
 972                     FreeVec(fn);
 973
 974                     SendBack(msg, 0);
 975                     continue;
 976                 }
 977                 case FSA_WRITE:
 978                     D(bug("Command is FSA_WRITE. "));
 979                     if (!(un->mode & FMF_WRITE))
 980                     {
 981                         D(bug("User doesn't have permission to write.\n"));
 982                         SendBack(msg, ERROR_BAD_STREAM_NAME);
 983                         continue;
 984                     }
 985                     if (!fn->numreaders)
 986                     {
 987                         D(bug("There are no more readers: PIPE BROKEN.\n"));
 988                         SendBack(msg, ERROR_BROKEN_PIPE);
 989                         continue;
 990                     }
 991                     if (un->mode & FMF_NONBLOCK && IsListEmpty(&fn->pendingreads))
 992                     {
 993                         D(bug("There are no pending reads and the pipe is in nonblocking mode, so return EWOULDBLOCK\n"));
 994                         SendBack(msg, ERROR_WOULD_BLOCK);
 995                         continue;
 996                     }
 997
 998                     D(bug("Enqueing the message\n"));
 999                     msg->curlen = msg->iofs->io_Union.io_READ_WRITE.io_Length;
1000                     AddTail(&fn->pendingwrites, (struct Node *)msg);
1001                     break;
1002                 case FSA_READ:
1003                     D(bug("Command is FSA_READ. "));
1004                     if (!(un->mode & FMF_READ))
1005                     {
1006                         D(bug("User doesn't have permission to read.\n"));
1007                         SendBack(msg, ERROR_BAD_STREAM_NAME);
1008                         continue;
1009                     }
1010                     if (!fn->numwriters)
1011                     {
1012                         D(bug("There's no data to read: send EOF\n"));
1013                         msg->iofs->io_Union.io_READ_WRITE.io_Length = 0;
1014                         SendBack(msg, 0);
1015                         continue;
1016                     }
1017                     if (un->mode & FMF_NONBLOCK  && IsListEmpty(&fn->pendingwrites))
1018                     {
1019                         D(bug("There are no pending writes and the pipe is in nonblocking mode, so return EWOULDBLOCK\n"));
1020                         SendBack(msg, ERROR_WOULD_BLOCK);
1021                         continue;
1022                     }
1023
1024                     D(bug("Enqueing the message\n"));
1025                     msg->curlen = msg->iofs->io_Union.io_READ_WRITE.io_Length;
1026                     AddTail(&fn->pendingreads, (struct Node *)msg);
1027                     break;
1028             }
1029
1030             while (!IsListEmpty(&fn->pendingwrites) && !IsListEmpty(&fn->pendingreads))
1031             {
1032                 struct pipefsmessage *rmsg = (struct pipefsmessage *)RemHead(&fn->pendingreads);
1033                 struct pipefsmessage *wmsg = (struct pipefsmessage *)RemHead(&fn->pendingwrites);
1034
1035                 ULONG len = (rmsg->curlen > wmsg->curlen) ?
1036                              wmsg->curlen : rmsg->curlen;
1037
1038                 D(bug("Writer len = %d - Reader len = %d. Copying %d bytes\n",
1039                          wmsg->curlen, rmsg->curlen, len));
1040
1041                 CopyMem
1042                 (
1043                     wmsg->iofs->io_Union.io_READ_WRITE.io_Buffer +
1044                     wmsg->iofs->io_Union.io_READ_WRITE.io_Length -
1045                     wmsg->curlen,
1046
1047                     rmsg->iofs->io_Union.io_READ_WRITE.io_Buffer +
1048                     rmsg->iofs->io_Union.io_READ_WRITE.io_Length -
1049                     rmsg->curlen,
1050
1051                     len
1052                 );
1053
1054                 wmsg->curlen -= len;
1055                 rmsg->curlen -= len;
1056
1057                 D(bug("Writer curlen is now %d - Reader curlen is now %d\n",
1058                          wmsg->curlen, rmsg->curlen));
1059
1060                 if (!wmsg->curlen)
1061                 {
1062                     D(bug("Writer: finished its job.\n"));
1063                     SendBack(wmsg, 0);
1064                 }
1065                 else
1066                 {
1067                     D(bug("Writer: not finished yet. Enqueueing the request again.\n"));
1068                     AddTail(&fn->pendingwrites, (struct Node *)wmsg);
1069                 }
1070
1071                 if (!rmsg->curlen)
1072                 {
1073                     D(bug("Reader: finished its job.\n"));
1074                     SendBack(rmsg, 0);
1075                 }
1076                 else
1077                 if
1078                 (
1079                     ((struct usernode *)rmsg->iofs->IOFS.io_Unit)->mode & FMF_NONBLOCK &&
1080                     rmsg->iofs->io_Union.io_READ_WRITE.io_Length > wmsg->iofs->io_Union.io_READ_WRITE.io_Length
1081                 )
1082                 {
1083                     D(bug("Reader: wants to read more data than it's actually available, but since it's in nonblocking mode return anyway\n"));
1084                     rmsg->iofs->io_Union.io_READ_WRITE.io_Length = len;
1085                     SendBack(rmsg, 0);
1086                 }
1087                 else
1088                 {
1089                     D(bug("Reader: not finished yet. Enqueueing the request again.\n"));
1090                     AddTail(&fn->pendingreads, (struct Node *)rmsg);
1091                 }
1092             }
1093         }
1094         D(bug("Coming back to wait for a new message\n"));
1095
1096     } while (cont);
1097
1098     return 0;
1099
1100     AROS_USERFUNC_EXIT
1101 }