rom/dos/sendpkt.c

   1 /*
   2     Copyright © 1995-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 #include <aros/debug.h>
  10 #include "dos_intern.h"
  11 #include <dos/dosextens.h>
  12 #include <dos/notify.h>
  13 #include <proto/exec.h>
  14 #include <exec/initializers.h>
  15 #include <string.h>
  16 #include <proto/utility.h>
  17
  18 /* TODO: This can be done much better! */
  19 #ifndef AROS_FAST_BPTR
  20 #define  BStrtoCStr(bstr) ({ \
  21     STRPTR cstr; \
  22     cstr = AllocMem(AROS_BSTR_strlen(bstr)+1, MEMF_PUBLIC); \
  23     if(cstr) \
  24     { \
  25         CopyMem(AROS_BSTR_ADDR(bstr), cstr, AROS_BSTR_strlen(bstr)); \
  26         cstr[AROS_BSTR_strlen(bstr)] = 0; \
  27     }  \
  28     cstr; \
  29 })
  30 #else
  31 #define  BStrtoCStr(bstr) ((STRPTR)bstr)
  32 #endif
  33
  34
  35 LONG DoNameAsynch(struct IOFileSys *iofs, STRPTR name,
  36                   struct DosLibrary *DOSBase);
  37
  38 /*****************************************************************************
  39
  40     NAME */
  41 #include <proto/dos.h>
  42
  43         AROS_LH3(void, SendPkt,
  44
  45 /*  SYNOPSIS */
  46         AROS_LHA(struct DosPacket *, dp, D1),
  47         AROS_LHA(struct MsgPort   *, port, D2),
  48         AROS_LHA(struct MsgPort   *, replyport, D3),
  49
  50 /*  LOCATION */
  51         struct DosLibrary *, DOSBase, 41, Dos)
  52
  53 /*  FUNCTION
  54
  55     Send a packet to a handler without waiting for the result. The packet will
  56     be returned to 'replyport'.
  57
  58     INPUTS
  59
  60     packet     --  the (initialized) packet to send
  61     port       --  the MsgPort to send the packet to
  62     replyport  --  the MsgPort to which the packet will be replied
  63
  64     RESULT
  65
  66     This function is callable from a task.
  67
  68     NOTES
  69
  70     EXAMPLE
  71
  72     BUGS
  73
  74     SEE ALSO
  75
  76     DoPkt(), WaitPkt(), AbortPkt()
  77
  78     INTERNALS
  79
  80 *****************************************************************************/
  81 {
  82     AROS_LIBFUNC_INIT
  83
  84     /*
  85      * Trying to emulate the packet system by rewriting the
  86      * packets to IO Requests. Sometimes there are too many
  87      * parameters in the packet but thats fine. If there are
  88      * not enough parameters or the wrong type etc. then
  89      * it is more difficult to translate the packet.
  90      *
  91      */
  92
  93     struct IOFileSys  *iofs = AllocMem(sizeof(struct IOFileSys), MEMF_CLEAR);
  94     struct FileHandle *fh;
  95     BPTR               oldCurDir;
  96     LONG               result;
  97
  98     if (iofs != NULL)
  99     {
 100         /*
 101          * Also attach the packet to the io request.
 102          * Will remain untouched by the driver.
 103          */
 104
 105         iofs->io_PacketEmulation = dp;
 106
 107         /*
 108          * In case the packet is to be aborted
 109          * I know which IORequest to use. The user will
 110          * use the packet itself to abort the operation.
 111          */
 112         dp->dp_Arg7 = (IPTR)iofs;
 113
 114
 115         iofs->IOFS.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
 116         iofs->IOFS.io_Message.mn_ReplyPort = replyport;
 117         iofs->IOFS.io_Message.mn_Length = sizeof(struct IOFileSys);
 118         iofs->IOFS.io_Flags = 0;
 119
 120         /*
 121          * Have to rewrite this packet...
 122          */
 123
 124         switch (dp->dp_Type)
 125         {
 126         case ACTION_NIL:
 127         case ACTION_READ_RETURN:
 128         case ACTION_WRITE_RETURN:
 129         case ACTION_TIMER:
 130             kprintf("This packet is a reserved one and should not be sent"
 131                     " by you!\n");
 132             // Alert();
 133             return;
 134
 135             // case ACTION_GET_BLOCK:
 136         case ACTION_DISK_CHANGE:
 137         case ACTION_DISK_TYPE:
 138         case ACTION_EVENT:
 139         case ACTION_SET_MAP:
 140
 141             kprintf("This packet is obsolete. (ACTION type %d)\n",
 142                     dp->dp_Type);
 143             return;
 144
 145
 146         case ACTION_FINDINPUT:      // Open() MODE_OLDFILE [*]
 147             fh = (struct FileHandle *)dp->dp_Arg2;
 148
 149             iofs->IOFS.io_Device = fh->fh_Device;
 150
 151             iofs->IOFS.io_Command = FSA_OPEN_FILE;
 152             iofs->io_Union.io_OPEN_FILE.io_FileMode = FMF_WRITE | FMF_READ;
 153
 154             oldCurDir = CurrentDir((BPTR)dp->dp_Arg2);
 155             result = DoNameAsynch(iofs, BStrtoCStr((BSTR)dp->dp_Arg3),
 156                                   DOSBase);
 157             CurrentDir(oldCurDir);
 158
 159             if (result != 0)
 160             {
 161                 kprintf("Error: Didn't find file\n");
 162                 return;
 163             }
 164
 165             kprintf("Returned from DoNameAsynch()\n");
 166
 167             break;
 168
 169         case ACTION_FINDOUTPUT:     // Open() MODE_NEWFILE [*]
 170             fh = (struct FileHandle *)dp->dp_Arg2;
 171
 172             iofs->IOFS.io_Device = fh->fh_Device;
 173
 174             iofs->IOFS.io_Command = FSA_OPEN_FILE;
 175             iofs->io_Union.io_OPEN_FILE.io_FileMode = FMF_LOCK |
 176                 FMF_CREATE | FMF_CLEAR | FMF_WRITE | FMF_READ;
 177
 178             oldCurDir = CurrentDir((BPTR)dp->dp_Arg2);
 179             result = DoNameAsynch(iofs, BStrtoCStr((BSTR)dp->dp_Arg3),
 180                                   DOSBase);
 181             CurrentDir(oldCurDir);
 182
 183             if (result != 0)
 184             {
 185                 return;
 186             }
 187
 188             break;
 189
 190
 191         case ACTION_FINDUPDATE:     // Open() MODE_READWRITE [*]
 192             fh = (struct FileHandle *)dp->dp_Arg2;
 193
 194             iofs->IOFS.io_Device = fh->fh_Device;
 195
 196             iofs->IOFS.io_Command = FSA_OPEN_FILE;
 197             iofs->io_Union.io_OPEN_FILE.io_FileMode = FMF_CREATE |
 198                 FMF_WRITE | FMF_READ;
 199
 200             oldCurDir = CurrentDir((BPTR)dp->dp_Arg2);
 201             result = DoNameAsynch(iofs, BStrtoCStr((BSTR)dp->dp_Arg3),
 202                                   DOSBase);
 203             CurrentDir(oldCurDir);
 204
 205             if (result != 0)
 206             {
 207                 return;
 208             }
 209
 210             break;
 211
 212         case ACTION_READ:           // Read() [*]
 213             fh = (struct FileHandle *)dp->dp_Arg1;
 214
 215             iofs->IOFS.io_Device = fh->fh_Device;
 216             iofs->IOFS.io_Unit   = fh->fh_Unit;
 217
 218             iofs->IOFS.io_Command = FSA_READ;
 219             iofs->io_Union.io_READ_WRITE.io_Buffer = (APTR)dp->dp_Arg2;
 220             iofs->io_Union.io_READ_WRITE.io_Length = (LONG)dp->dp_Arg3;
 221
 222             break;
 223
 224
 225         case ACTION_WRITE:          // Write() [*]
 226             fh = (struct FileHandle *)dp->dp_Arg1;
 227
 228             iofs->IOFS.io_Device = fh->fh_Device;
 229             iofs->IOFS.io_Unit   = fh->fh_Unit;
 230
 231             iofs->IOFS.io_Command = FSA_WRITE;
 232             iofs->io_Union.io_READ_WRITE.io_Buffer = (APTR)dp->dp_Arg2;
 233             iofs->io_Union.io_READ_WRITE.io_Length = (LONG)dp->dp_Arg3;
 234
 235             break;
 236
 237         case ACTION_SEEK:           // Seek()      [*] CH
 238             fh = (struct FileHandle *)dp->dp_Arg1;
 239
 240             iofs->IOFS.io_Device = fh->fh_Device;
 241             iofs->IOFS.io_Unit   = fh->fh_Unit;
 242
 243             /* If the file is in write mode flush it. This is done
 244                synchronously as otherwise the seek may be served before
 245                the flush. (TODO: What are a reasonable semantics here?) */
 246             if (fh->fh_Flags & FHF_WRITE)
 247             {
 248                 Flush(MKBADDR(fh));
 249             }
 250             else
 251             {
 252                 /* Read mode. Just reinit the buffers. We can't call
 253                    Flush() in this case as that would end up in recursion. */
 254                 fh->fh_Pos = fh->fh_End = fh->fh_Buf;
 255             }
 256
 257             iofs->IOFS.io_Command = FSA_SEEK;
 258             iofs->io_Union.io_SEEK.io_Offset = (QUAD)dp->dp_Arg2;
 259             iofs->io_Union.io_SEEK.io_SeekMode = dp->dp_Arg3;
 260
 261             break;
 262
 263         case ACTION_SET_FILE_SIZE:  // SetFileSize()        [*]
 264             fh = (struct FileHandle *)dp->dp_Arg1;
 265
 266             iofs->IOFS.io_Device = fh->fh_Device;
 267             iofs->IOFS.io_Unit   = fh->fh_Unit;
 268
 269             iofs->IOFS.io_Command = FSA_SET_FILE_SIZE;
 270             iofs->io_Union.io_SET_FILE_SIZE.io_Offset   = (QUAD)dp->dp_Arg2;
 271             iofs->io_Union.io_SET_FILE_SIZE.io_SeekMode = dp->dp_Arg3;
 272             break;
 273
 274         case ACTION_EXAMINE_FH:     // ExamineFH()
 275         case ACTION_EXAMINE_OBJECT: // Examine() [*]  --  the same thing
 276                                     //                    in AROS
 277             {
 278                 UBYTE *buffer = AllocVec(sizeof(struct ExAllData),
 279                                          MEMF_PUBLIC | MEMF_CLEAR);
 280
 281                 if (buffer == NULL)
 282                 {
 283                     dp->dp_Res1 = DOSFALSE;
 284                     dp->dp_Res2 = ERROR_NO_FREE_STORE;
 285
 286                     return;
 287                 }
 288
 289                 fh = (struct FileHandle *)dp->dp_Arg1;
 290
 291                 iofs->IOFS.io_Device = fh->fh_Device;
 292                 iofs->IOFS.io_Unit   = fh->fh_Unit;
 293
 294                 iofs->IOFS.io_Command = FSA_EXAMINE;
 295                 iofs->io_Union.io_EXAMINE.io_ead = (struct ExAllData *)buffer;
 296                 iofs->io_Union.io_EXAMINE.io_Size = sizeof(struct ExAllData);
 297                 iofs->io_Union.io_EXAMINE.io_Mode = ED_OWNER;
 298
 299                 /* A supplied FileInfoBlock (is a BPTR) is in dp_Arg2 */
 300
 301                 break;
 302             }
 303
 304         case ACTION_EXAMINE_NEXT:   // ExNext() [*]
 305             fh = (struct FileHandle *)dp->dp_Arg1;
 306
 307             iofs->IOFS.io_Device = fh->fh_Device;
 308             iofs->IOFS.io_Unit   = fh->fh_Unit;
 309
 310             iofs->IOFS.io_Command = FSA_EXAMINE_NEXT;
 311             iofs->io_Union.io_EXAMINE_NEXT.io_fib = (BPTR)dp->dp_Arg2;
 312
 313             break;
 314
 315         case ACTION_CREATE_DIR:     // CreateDir() [*]
 316             fh = (struct FileHandle *)dp->dp_Arg1;
 317
 318             iofs->IOFS.io_Device = fh->fh_Device;
 319             iofs->IOFS.io_Unit   = fh->fh_Unit;
 320
 321             iofs->IOFS.io_Command = FSA_CREATE_DIR;
 322             iofs->io_Union.io_CREATE_DIR.io_Filename = BStrtoCStr((BSTR)dp->dp_Arg2);
 323             iofs->io_Union.io_CREATE_DIR.io_Protection = 0;
 324
 325             break;
 326
 327
 328         case ACTION_DELETE_OBJECT:  // DeleteFile()     [*]
 329             // ARG1:   LOCK    Lock to which ARG2 is relative
 330             // ARG2:   BSTR    Name of object to delete (relative to ARG1)
 331
 332             fh = (struct FileHandle *)dp->dp_Arg1;
 333
 334             iofs->IOFS.io_Device = fh->fh_Device;
 335             iofs->IOFS.io_Unit   = fh->fh_Unit;
 336
 337             /* IFS_DELETE_OBJECT just consists of a STRPTR so we have to
 338                use NameFromLock() here -- TODO */
 339             // iofs->io_Union.io_DELETE_OBJECT.io_Filename = BStrtoCStr((BSTR)dp->dp_Arg2);
 340             iofs->IOFS.io_Command = FSA_DELETE_OBJECT;
 341
 342             break;
 343
 344         case ACTION_RENAME_OBJECT:  // Rename()
 345             /* TODO */
 346             break;
 347
 348         case ACTION_LOCK_RECORD:    // LockRecord()
 349             fh = (struct FileHandle *)BADDR(dp->dp_Arg1);
 350
 351             iofs->IOFS.io_Device = fh->fh_Device;
 352             iofs->IOFS.io_Unit = fh->fh_Unit;
 353
 354             iofs->io_Union.io_RECORD.io_Offset = (QUAD)dp->dp_Arg2;
 355             iofs->io_Union.io_RECORD.io_Size = (LONG)dp->dp_Arg3;
 356             iofs->io_Union.io_RECORD.io_RecordMode = (LONG)dp->dp_Arg4;
 357             iofs->io_Union.io_RECORD.io_Timeout = (LONG)dp->dp_Arg5;
 358             break;
 359
 360         case ACTION_FREE_RECORD:    // UnlockRecord()
 361             fh = (struct FileHandle *)BADDR(dp->dp_Arg1);
 362
 363             iofs->IOFS.io_Device = fh->fh_Device;
 364             iofs->IOFS.io_Unit = fh->fh_Unit;
 365
 366             iofs->io_Union.io_RECORD.io_Offset = (QUAD)dp->dp_Arg2;
 367             iofs->io_Union.io_RECORD.io_Size = (LONG)dp->dp_Arg3;
 368             iofs->io_Union.io_RECORD.io_RecordMode = (LONG)dp->dp_Arg4;
 369             break;
 370
 371         case ACTION_PARENT:         // ParentDir()     [*]
 372             fh = (struct FileHandle *)dp->dp_Arg1;
 373
 374             iofs->IOFS.io_Device = fh->fh_Device;
 375             iofs->IOFS.io_Unit   = fh->fh_Unit;
 376
 377             iofs->IOFS.io_Command = FSA_OPEN;
 378             iofs->io_Union.io_OPEN.io_FileMode = FMF_READ; // Shared lock
 379
 380             oldCurDir = CurrentDir((BPTR)dp->dp_Arg1);
 381             result = DoNameAsynch(iofs, "/", DOSBase);
 382             CurrentDir(oldCurDir);
 383
 384             if (result != 0)
 385             {
 386                 return;
 387             }
 388
 389             return;
 390
 391         case ACTION_SET_PROTECT:    // SetProtection()    [*]
 392             // STRPTR io_Filename;   /* The file to change. */
 393             // ULONG  io_Protection; /* The new protection bits. */
 394
 395             fh = (struct FileHandle *)dp->dp_Arg2;
 396
 397             iofs->IOFS.io_Device = fh->fh_Device;
 398             iofs->IOFS.io_Unit   = fh->fh_Unit;
 399
 400             iofs->IOFS.io_Command = FSA_SET_PROTECT;
 401             iofs->io_Union.io_SET_PROTECT.io_Protection = dp->dp_Arg4;
 402             iofs->io_Union.io_SET_PROTECT.io_Filename = BStrtoCStr(dp->dp_Arg3);
 403
 404             break;
 405
 406         case ACTION_SET_COMMENT:    // SetComment()       [*]
 407             fh = (struct FileHandle *)dp->dp_Arg2;
 408
 409             iofs->IOFS.io_Device = fh->fh_Device;
 410             iofs->IOFS.io_Unit   = fh->fh_Unit;
 411
 412             iofs->IOFS.io_Command = FSA_SET_COMMENT;
 413             iofs->io_Union.io_SET_COMMENT.io_Filename = BStrtoCStr((BSTR)dp->dp_Arg3);
 414             iofs->io_Union.io_SET_COMMENT.io_Comment = BStrtoCStr(dp->dp_Arg4);
 415
 416             break;
 417
 418         case ACTION_LOCATE_OBJECT:  // Lock()         [*]
 419             fh = (struct FileHandle *)dp->dp_Arg1;
 420
 421             iofs->IOFS.io_Device = fh->fh_Device;
 422             iofs->IOFS.io_Unit   = fh->fh_Unit;
 423
 424             iofs->IOFS.io_Command = FSA_OPEN;
 425
 426             switch (dp->dp_Arg3)
 427             {
 428             case EXCLUSIVE_LOCK:
 429                 iofs->io_Union.io_OPEN.io_FileMode = FMF_LOCK | FMF_READ;
 430                 break;
 431
 432             case SHARED_LOCK:
 433                 iofs->io_Union.io_OPEN.io_FileMode = FMF_READ;
 434                 break;
 435
 436             default:
 437                 iofs->io_Union.io_OPEN.io_FileMode = dp->dp_Arg3;
 438                 break;
 439             }
 440
 441             oldCurDir = CurrentDir((BPTR)dp->dp_Arg1);
 442             result = DoNameAsynch(iofs, BStrtoCStr((BSTR)dp->dp_Arg2),
 443                                   DOSBase);
 444             CurrentDir(oldCurDir);
 445
 446             if (result != 0)
 447             {
 448                 return;
 449             }
 450
 451             dp->dp_Arg6 = (IPTR)AllocDosObject(DOS_FILEHANDLE, NULL);
 452
 453             if (dp->dp_Arg6 == (IPTR)NULL)
 454             {
 455                 return;
 456             }
 457
 458             break;
 459
 460         case ACTION_COPY_DIR:       // DupLock()
 461         case ACTION_COPY_DIR_FH:    // DupLockFromFH() -- the same thing
 462                                     //                    in AROS
 463             fh = (struct FileHandle *)BADDR(dp->dp_Arg1);
 464
 465             iofs->IOFS.io_Device = fh->fh_Device;
 466             iofs->IOFS.io_Unit   = fh->fh_Unit;
 467
 468             iofs->IOFS.io_Command = FSA_OPEN;
 469
 470             /* Create a shared lock */
 471             iofs->io_Union.io_OPEN.io_FileMode = FMF_READ;
 472
 473             oldCurDir = CurrentDir((BPTR)dp->dp_Arg1);
 474             result = DoNameAsynch(iofs, "", DOSBase);
 475             CurrentDir(oldCurDir);
 476
 477             if (result != 0)
 478             {
 479                 return;
 480             }
 481
 482             dp->dp_Arg6 = (IPTR)AllocDosObject(DOS_FILEHANDLE, NULL);
 483
 484             if (dp->dp_Arg6 == (IPTR)NULL)
 485             {
 486                 return;
 487             }
 488
 489             break;
 490
 491         case ACTION_END:            // Close() [*]
 492         case ACTION_FREE_LOCK:      // UnLock() -- the same thing in AROS
 493             fh = (struct FileHandle *)dp->dp_Arg1;
 494
 495             iofs->IOFS.io_Device = fh->fh_Device;
 496             iofs->IOFS.io_Unit   = fh->fh_Unit;
 497
 498             /* If the filehandle has a pending write on it Flush() the buffer.
 499                This is made synchronously... */
 500             if (fh->fh_Flags & FHF_WRITE)
 501             {
 502                 Flush(MKBADDR(fh));
 503             }
 504
 505             iofs->IOFS.io_Command = FSA_CLOSE;
 506
 507             break;
 508
 509         case ACTION_SET_DATE:       // SetFileDate() [*]
 510             fh = (struct FileHandle *)dp->dp_Arg2;
 511
 512             iofs->IOFS.io_Device = fh->fh_Device;
 513             iofs->IOFS.io_Unit   = fh->fh_Unit;
 514
 515             iofs->IOFS.io_Command = FSA_SET_DATE;
 516             memcpy(&iofs->io_Union.io_SET_DATE.io_Date, (APTR)dp->dp_Arg4,
 517                    sizeof(struct DateStamp));
 518
 519             oldCurDir = CurrentDir((BPTR)dp->dp_Arg2);
 520             result = DoNameAsynch(iofs, BStrtoCStr((BSTR)dp->dp_Arg3),
 521                                   DOSBase);
 522             CurrentDir(oldCurDir);
 523
 524             if (result != 0)
 525             {
 526                 return;
 527             }
 528
 529             break;
 530
 531         case ACTION_SAME_LOCK:      // SameLock() [*]
 532             fh = (struct FileHandle *)dp->dp_Arg1;
 533
 534             iofs->IOFS.io_Device = fh->fh_Device;
 535             iofs->IOFS.io_Unit   = fh->fh_Unit;
 536
 537             iofs->IOFS.io_Command = FSA_SAME_LOCK;
 538
 539             iofs->io_Union.io_SAME_LOCK.io_Lock[0] = BADDR((BPTR)dp->dp_Arg1);
 540             iofs->io_Union.io_SAME_LOCK.io_Lock[1] = BADDR((BPTR)dp->dp_Arg2);
 541
 542             break;
 543
 544         case ACTION_MAKE_LINK:      // MakeLink()
 545             {
 546                 STRPTR name = BStrtoCStr(dp->dp_Arg2);
 547
 548                 if (dp->dp_Arg4 == LINK_SOFT)
 549                 {
 550                     /* We want a soft-link. */
 551                     iofs->IOFS.io_Command = FSA_CREATE_SOFTLINK;
 552                     iofs->io_Union.io_CREATE_SOFTLINK.io_Reference = (STRPTR)dp->dp_Arg3;
 553                 }
 554                 else
 555                 {
 556                     /* We want a hard-link. */
 557                     struct FileHandle *fh = (struct FileHandle *)BADDR((BPTR)dp->dp_Arg3);
 558                     struct DevProc *dvp;
 559
 560                     /* We check, if name and dest are on the same device. */
 561                     if ((dvp = GetDeviceProc(name, NULL)) == NULL)
 562                     {
 563                         /* TODO: Simulate packet return */
 564                         return;
 565                     }
 566
 567                     if (dvp->dvp_Port != (struct MsgPort *)fh->fh_Device)
 568                     {
 569                         FreeDeviceProc(dvp);
 570                         SetIoErr(ERROR_RENAME_ACROSS_DEVICES);
 571
 572                         /* TODO: Simulate packet return */
 573                         return;
 574                     }
 575
 576                     FreeDeviceProc(dvp);
 577
 578                     iofs->IOFS.io_Command = FSA_CREATE_HARDLINK;
 579                     iofs->io_Union.io_CREATE_HARDLINK.io_OldFile = fh->fh_Unit;
 580                 }
 581
 582                 oldCurDir = CurrentDir((BPTR)dp->dp_Arg1);
 583                 DoNameAsynch(iofs, name, DOSBase);
 584                 CurrentDir(oldCurDir);
 585             }
 586
 587             break;
 588
 589         case ACTION_READ_LINK:      // ReadLink()
 590             /* TODO */
 591             break;
 592
 593         case ACTION_EXAMINE_ALL:    // ExAll()
 594             /* TODO */
 595             break;
 596
 597         case ACTION_ADD_NOTIFY:     // StartNotify()
 598             {
 599                 struct NotifyRequest *notify = (struct NotifyRequest *)BADDR(dp->dp_Arg1);
 600                 struct FileHandle *dir;
 601
 602                 iofs->IOFS.io_Command = FSA_ADD_NOTIFY;
 603                 iofs->io_Union.io_NOTIFY.io_NotificationRequest = notify;
 604
 605                 notify->nr_MsgCount = 0;
 606
 607                 if (strchr(notify->nr_Name, ':') != NULL)
 608                 {
 609                     DoNameAsynch(iofs, notify->nr_Name, DOSBase);
 610                 }
 611                 else
 612                 {
 613                     dir = BADDR(CurrentDir(NULL));
 614                     CurrentDir(MKBADDR(dir));   /* Set back the current dir */
 615
 616                     if (dir == NULL)
 617                     {
 618                         return;
 619                     }
 620
 621                     iofs->IOFS.io_Device = dir->fh_Device;
 622                     iofs->IOFS.io_Unit = dir->fh_Unit;
 623
 624                     /* Save device for EndNotify() purposes */
 625                     notify->nr_Handler = (struct MsgPort *) dir->fh_Device;
 626
 627                     if (iofs->IOFS.io_Device == NULL)
 628                     {
 629                         return;
 630                     }
 631                 }
 632             }
 633
 634             break;
 635
 636         case ACTION_REMOVE_NOTIFY:  // EndNotify()
 637             {
 638                 struct NotifyRequest *notify = (struct NotifyRequest *)BADDR(dp->dp_Arg1);
 639
 640                 iofs->IOFS.io_Command = FSA_REMOVE_NOTIFY;
 641                 iofs->io_Union.io_NOTIFY.io_NotificationRequest = notify;
 642
 643                 if (strchr(notify->nr_Name, ':'))
 644                 {
 645                     DoNameAsynch(iofs, notify->nr_Name, DOSBase);
 646                 }
 647                 else
 648                 {
 649                     iofs->IOFS.io_Device = (struct Device *)notify->nr_Handler;
 650
 651                     if (iofs->IOFS.io_Device == NULL)
 652                     {
 653                         return;
 654                     }
 655                 }
 656             }
 657
 658             break;
 659
 660
 661             /* The following five packets are only relative to the
 662                message port of the file system to send to. Therefore,
 663                we fill in only partial information in the IOFileSys and
 664                hope for the best... Specifically, the device cannot
 665                use iofs->io_Device. TODO */
 666         case ACTION_RENAME_DISK:    // Relabel()
 667             /* TODO */
 668             break;
 669
 670         case ACTION_FORMAT:         // Format()
 671             /* TODO */
 672             break;
 673
 674         case ACTION_MORE_CACHE:     // AddBuffers()
 675             /* TODO */
 676             break;
 677
 678         case ACTION_INHIBIT:        // Inhibit()
 679             /* TODO */
 680             break;
 681
 682         case ACTION_IS_FILESYSTEM:  // IsFileSystem()
 683             /* TODO */
 684             break;
 685
 686         case ACTION_DISK_INFO:      // Info()
 687             /* TODO */
 688             break;
 689
 690         case ACTION_INFO:           // No associated function
 691             /* TODO */
 692             break;
 693
 694         case ACTION_CURRENT_VOLUME: // No associated function
 695             /* TODO */
 696             break;
 697
 698         case ACTION_PARENT_FH:      // ParentOfFH()
 699             /* TODO -- Should be the same as ACTION_PARENT? For some reason
 700                        ParentDir() and ParentOfFH() is implemented differently
 701                        in AROS. Have to investigate this further. */
 702             break;
 703
 704         case ACTION_FH_FROM_LOCK:   // OpenFromLock()
 705             /* TODO: Have so simulate ReplyMsg() here */
 706             return;
 707
 708         case ACTION_SET_OWNER:      // SetOwner()
 709             // Unfortunately, I have no info regardning this packet.
 710
 711             // iofs->IOFS.io_Command = FSA_SET_OWNER;
 712             // iofs->io_Union.io_SET_OWNER.io_UID = owner_info >> 16;
 713             // iofs->io_Union.io_SET_OWNER.io_GID = owner_info & 0xffff;
 714
 715             break;
 716
 717         case ACTION_CHANGE_MODE:    // ChangeMode()
 718             /* TODO */
 719             break;
 720
 721             /* I haven't looked into the following packets in detail */
 722         case ACTION_DIE:            // No associated function
 723             break;
 724
 725         case ACTION_WRITE_PROTECT:  // No associated function
 726             break;
 727
 728         case ACTION_FLUSH:          // No associated function
 729             break;
 730
 731         case ACTION_SERIALIZE_DISK: // No associated function
 732             break;
 733
 734
 735             // ---  Console only packets  ------------------------------
 736             /* I think these should not be implemented as packets except
 737                for ACTION_WAIT_CHAR which is not really a console only
 738                packet. Instead functions should be added to console.device */
 739
 740         case ACTION_SCREEN_MODE:    // SetMode()
 741             /* TODO*/
 742             break;
 743
 744         case ACTION_CHANGE_SIGNAL:  // No associated function
 745             {
 746                 struct MsgPort *msgport;
 747                 struct Task    *task;
 748
 749                 fh = (struct FileHandle *)dp->dp_Arg1;
 750                 msgport = (struct MsgPort *)dp->dp_Arg2;
 751                 task = msgport ? msgport->mp_SigTask : NULL;
 752
 753                 iofs->IOFS.io_Device = fh->fh_Device;
 754                 iofs->IOFS.io_Unit   = fh->fh_Unit;
 755
 756                 iofs->IOFS.io_Command = FSA_CHANGE_SIGNAL;
 757                 iofs->io_Union.io_CHANGE_SIGNAL.io_Task = task;
 758             }
 759             break;
 760
 761         case ACTION_WAIT_CHAR:      // WaitForChar()
 762             /* TODO */
 763             break;
 764
 765         default:
 766             kprintf("Unknown packet type %d found in SendPkt()\n",
 767                     dp->dp_Type);
 768             return;
 769         }
 770
 771         kprintf("Calling SendIO() with command %u\n", iofs->IOFS.io_Command);
 772
 773         SendIO((struct IORequest *)iofs);
 774     }
 775
 776    AROS_LIBFUNC_EXIT
 777 } /* SendPkt */
 778
 779
 780 LONG DoNameAsynch(struct IOFileSys *iofs, STRPTR name,
 781                   struct DosLibrary *DOSBase)
 782 {
 783     STRPTR volname, pathname, s1 = NULL;
 784     BPTR cur, lock = (BPTR)NULL;
 785     struct DosList    *dl;
 786     struct Device     *device;
 787     struct Unit       *unit;
 788     struct FileHandle *fh;
 789     struct Process    *me = (struct Process *)FindTask(NULL);
 790
 791     if (!Strnicmp(name, "PROGDIR:", 8) && me->pr_HomeDir)
 792     {
 793         cur = me->pr_HomeDir;
 794         volname = NULL;
 795         pathname = name + 8;
 796     }
 797     else if (*name == ':')
 798     {
 799         cur = me->pr_CurrentDir;
 800         volname = NULL;
 801         pathname = name + 1;
 802     }
 803     else
 804     {
 805         /* Copy volume name */
 806         cur = me->pr_CurrentDir;
 807         s1 = name;
 808         pathname = name;
 809         volname = NULL;
 810
 811         while (*s1)
 812         {
 813             if (*s1++ == ':')
 814             {
 815                 volname = (STRPTR)AllocMem(s1-name, MEMF_ANY);
 816
 817                 if (volname == NULL)
 818                 {
 819                     return ERROR_NO_FREE_STORE;
 820                 }
 821
 822                 CopyMem(name, volname, s1 - name - 1);
 823
 824                 volname[s1 - name - 1] = '\0';
 825                 pathname = s1;
 826                 break;
 827             }
 828         }
 829     }
 830
 831     if (!volname && !cur && !DOSBase->dl_SYSLock)
 832     {
 833         return ERROR_OBJECT_NOT_FOUND;
 834     }
 835
 836     dl = LockDosList(LDF_ALL | LDF_READ);
 837
 838     if (volname != NULL)
 839     {
 840         /* Find logical device */
 841         dl = FindDosEntry(dl, volname, LDF_ALL);
 842
 843         if (dl == NULL)
 844         {
 845             UnLockDosList(LDF_ALL | LDF_READ);
 846             FreeMem(volname, s1 - name);
 847
 848             return ERROR_DEVICE_NOT_MOUNTED;
 849         }
 850         else if (dl->dol_Type == DLT_LATE)
 851         {
 852             lock = Lock(dl->dol_misc.dol_assign.dol_AssignName, SHARED_LOCK);
 853             UnLockDosList(LDF_ALL | LDF_READ);
 854
 855             if (lock != NULL)
 856             {
 857                 AssignLock(volname, lock);
 858                 dl = LockDosList(LDF_ALL | LDF_READ);
 859                 dl = FindDosEntry(dl, volname, LDF_ALL);
 860
 861                 if (dl == NULL)
 862                 {
 863                     UnLockDosList(LDF_ALL | LDF_READ);
 864                     FreeMem(volname, s1 - name);
 865
 866                     return ERROR_DEVICE_NOT_MOUNTED;
 867                 }
 868
 869                 device = dl->dol_Ext.dol_AROS.dol_Device;
 870                 unit = dl->dol_Ext.dol_AROS.dol_Unit;
 871             }
 872             else
 873             {
 874                 FreeMem(volname, s1 - name);
 875
 876                 return IoErr();
 877             }
 878         }
 879         else if (dl->dol_Type == DLT_NONBINDING)
 880         {
 881             lock = Lock(dl->dol_misc.dol_assign.dol_AssignName, SHARED_LOCK);
 882             fh = (struct FileHandle *)BADDR(lock);
 883
 884             if (fh != NULL)
 885             {
 886                 device = fh->fh_Device;
 887                 unit = fh->fh_Unit;
 888             }
 889             else
 890             {
 891                 UnLockDosList(LDF_ALL | LDF_READ);
 892                 FreeMem(volname, s1 - name);
 893
 894                 return IoErr();
 895             }
 896         }
 897         else
 898         {
 899             device = dl->dol_Ext.dol_AROS.dol_Device;
 900             unit   = dl->dol_Ext.dol_AROS.dol_Unit;
 901         }
 902     }
 903     else if (cur)
 904     {
 905         fh = (struct FileHandle *)BADDR(cur);
 906         device = fh->fh_Device;
 907         unit = fh->fh_Unit;
 908     }
 909     else
 910     {
 911     #if 0
 912         /* stegerg: ?? */
 913         device = DOSBase->dl_NulHandler;
 914         unit = DOSBase->dl_NulLock;
 915     #else
 916         fh = (struct FileHandle *)BADDR(DOSBase->dl_SYSLock);
 917         device = fh->fh_Device;
 918         unit = fh->fh_Unit;
 919     #endif
 920     }
 921
 922     iofs->IOFS.io_Device = device;
 923     iofs->IOFS.io_Unit = unit;
 924     iofs->io_Union.io_NamedFile.io_Filename = pathname;
 925
 926     if (volname != NULL)
 927     {
 928         FreeMem(volname, s1 - name);
 929     }
 930
 931     return 0;
 932 }