workbench/fs/fat/packet.c

   1 /*
   2  * fat.handler - FAT12/16/32 filesystem handler
   3  *
   4  * Copyright © 2006 Marek Szyprowski
   5  * Copyright © 2007-2008 The AROS Development Team
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the same terms as AROS itself.
   9  *
  10  * $Id$
  11  */
  12
  13 #include <exec/types.h>
  14 #include <exec/execbase.h>
  15 #include <dos/dosextens.h>
  16 #include <dos/filehandler.h>
  17 #include <dos/notify.h>
  18 #include <devices/inputevent.h>
  19
  20 #include <proto/exec.h>
  21 #include <proto/dos.h>
  22
  23 #include <string.h>
  24
  25 #include "fat_fs.h"
  26 #include "fat_protos.h"
  27
  28 #define DEBUG DEBUG_PACKETS
  29 #include "debug.h"
  30
  31 void ProcessPackets(void) {
  32     struct Message *msg;
  33     struct DosPacket *pkt;
  34     struct MsgPort *rp;
  35
  36     while ((msg = GetMsg(glob->ourport)) != NULL) {
  37         LONG res = DOSFALSE;
  38         LONG err = 0;
  39
  40         pkt = (struct DosPacket *) msg->mn_Node.ln_Name;
  41
  42         switch(pkt->dp_Type) {
  43             case ACTION_LOCATE_OBJECT: {
  44                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1), *lock;
  45                 UBYTE *path = BADDR(pkt->dp_Arg2);
  46                 LONG access = pkt->dp_Arg3;
  47
  48                 D(bug("[fat] LOCATE_OBJECT: lock 0x%08x (dir %ld/%ld) name '", pkt->dp_Arg1,
  49                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0);
  50                 RawPutChars(&path[1], path[0]); bug("' type %s\n",
  51                       pkt->dp_Arg3 == EXCLUSIVE_LOCK ? "EXCLUSIVE" : "SHARED"));
  52
  53                 if ((err = TestLock(fl)))
  54                     break;
  55
  56                 if ((err = OpLockFile(fl, &path[1], path[0], access, &lock)) == 0)
  57                     res = (LONG)MKBADDR(lock);
  58
  59                 break;
  60             }
  61
  62             case ACTION_FREE_LOCK: {
  63                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1);
  64
  65                 D(bug("[fat] FREE_LOCK: lock 0x%08x (dir %ld/%ld)\n",
  66                       pkt->dp_Arg1,
  67                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0));
  68
  69                 OpUnlockFile(fl);
  70
  71                 res = DOSTRUE;
  72                 break;
  73             }
  74
  75             case ACTION_COPY_DIR:
  76             case ACTION_COPY_DIR_FH: {
  77                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1), *lock;
  78
  79                 D(bug("[fat] COPY_DIR: lock 0x%08x (dir %ld/%ld)\n",
  80                       pkt->dp_Arg1,
  81                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0));
  82
  83                 if ((err = TestLock(fl)))
  84                     break;
  85
  86                 if ((err = OpCopyLock(fl, &lock)) == 0)
  87                     res = (LONG)MKBADDR(lock);
  88
  89                 break;
  90             }
  91
  92             case ACTION_PARENT:
  93             case ACTION_PARENT_FH: {
  94                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1), *lock;
  95
  96                 D(bug("[fat] ACTION_PARENT: lock 0x%08x (dir %ld/%ld)\n",
  97                       pkt->dp_Arg1,
  98                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0));
  99
 100                 if ((err = TestLock(fl)))
 101                     break;
 102
 103                 if ((err = OpLockParent(fl, &lock)) == 0)
 104                     res = (LONG)MKBADDR(lock);
 105
 106                 break;
 107             }
 108
 109             case ACTION_SAME_LOCK: {
 110                 struct ExtFileLock *fl1 = BADDR(pkt->dp_Arg1);
 111                 struct ExtFileLock *fl2 = BADDR(pkt->dp_Arg2);
 112
 113                 D(bug("[fat] ACTION_SAME_LOCK: lock #1 0x%08x (dir %ld/%ld) lock #2 0x%08x (dir %ld/%ld)\n",
 114                       pkt->dp_Arg1,
 115                       fl1 != NULL ? fl1->gl->dir_cluster : 0, fl1 != NULL ? fl1->gl->dir_entry : 0,
 116                       pkt->dp_Arg2,
 117                       fl2 != NULL ? fl2->gl->dir_cluster : 0, fl2 != NULL ? fl2->gl->dir_entry : 0));
 118
 119                 err = 0;
 120
 121                 if (fl1 == fl2 || fl1->gl == fl2->gl)
 122                     res = DOSTRUE;
 123
 124                 break;
 125             }
 126
 127             case ACTION_EXAMINE_OBJECT:
 128             case ACTION_EXAMINE_FH: {
 129                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1);
 130                 struct FileInfoBlock *fib = BADDR(pkt->dp_Arg2);
 131
 132                 D(bug("[fat] EXAMINE_OBJECT: lock 0x%08x (dir %ld/%ld)\n",
 133                       pkt->dp_Arg1,
 134                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0));
 135
 136                 if ((err = TestLock(fl)))
 137                     break;
 138
 139                 if ((err = FillFIB(fl, fib)) == 0)
 140                     res = DOSTRUE;
 141
 142                 break;
 143             }
 144
 145             case ACTION_EXAMINE_NEXT: {
 146                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1), *lock;
 147                 struct FileInfoBlock *fib = BADDR(pkt->dp_Arg2);
 148                 struct DirHandle dh;
 149                 struct DirEntry de;
 150
 151                 D(bug("[fat] EXAMINE_NEXT: lock 0x%08x (dir %ld/%ld)\n",
 152                       pkt->dp_Arg1,
 153                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0));
 154
 155                 if ((err = TestLock(fl)))
 156                     break;
 157
 158                 if ((err = InitDirHandle(glob->sb, fl->ioh.first_cluster, &dh, FALSE)) != 0)
 159                     break;
 160
 161                 dh.cur_index = fib->fib_DiskKey;
 162
 163                 if ((err = GetNextDirEntry(&dh, &de)) != 0) {
 164                     if (err == ERROR_OBJECT_NOT_FOUND)
 165                         err = ERROR_NO_MORE_ENTRIES;
 166                     ReleaseDirHandle(&dh);
 167                     break;
 168                 }
 169
 170                 if ((err = LockFile(fl->ioh.first_cluster, dh.cur_index, SHARED_LOCK, &lock)) != 0) {
 171                     ReleaseDirHandle(&dh);
 172                     break;
 173                 }
 174
 175                 if ((err = FillFIB(lock, fib))) {
 176                     FreeLock(lock);
 177                     ReleaseDirHandle(&dh);
 178                     break;
 179                 }
 180
 181                 fib->fib_DiskKey = dh.cur_index;
 182
 183                 FreeLock(lock);
 184
 185                 ReleaseDirHandle(&dh);
 186
 187                 res = DOSTRUE;
 188
 189                 break;
 190             }
 191
 192             case ACTION_FINDINPUT:
 193             case ACTION_FINDOUTPUT:
 194             case ACTION_FINDUPDATE: {
 195                 struct FileHandle *fh = BADDR(pkt->dp_Arg1);
 196                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg2);
 197                 UBYTE *path = BADDR(pkt->dp_Arg3);
 198                 struct ExtFileLock *lock;
 199
 200                 D(bug("[fat] %s: lock 0x%08x (dir %ld/%ld) path '",
 201                       pkt->dp_Type == ACTION_FINDINPUT  ? "FINDINPUT"  :
 202                       pkt->dp_Type == ACTION_FINDOUTPUT ? "FINDOUTPUT" :
 203                                                           "FINDUPDATE",
 204                       pkt->dp_Arg2,
 205                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0);
 206                   RawPutChars(&path[1], path[0]); bug("'\n"));
 207
 208                 if ((err = TestLock(fl)))
 209                     break;
 210
 211                 if ((err = OpOpenFile(fl, &path[1], path[0], pkt->dp_Type, &lock)) != 0)
 212                     break;
 213
 214                 fh->fh_Arg1 = (LONG)MKBADDR(lock);
 215                 fh->fh_Port = DOSFALSE;
 216
 217                 res = DOSTRUE;
 218
 219                 break;
 220             }
 221
 222             case ACTION_READ: {
 223                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1);
 224                 APTR buffer = (APTR)pkt->dp_Arg2;
 225                 ULONG want = pkt->dp_Arg3;
 226
 227                 D(bug("[fat] READ: lock 0x%08x (dir %ld/%ld pos %ld) want %ld\n",
 228                       pkt->dp_Arg1,
 229                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0,
 230                       fl->pos,
 231                       want));
 232
 233                 if ((err = TestLock(fl))) {
 234                     res = -1;
 235                     break;
 236                 }
 237
 238                 if ((err = OpRead(fl, buffer, want, &res)) != 0)
 239                     res = -1;
 240
 241                 break;
 242             }
 243
 244             case ACTION_WRITE: {
 245                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1);
 246                 APTR buffer = (APTR)pkt->dp_Arg2;
 247                 ULONG want = pkt->dp_Arg3;
 248
 249                 D(bug("[fat] WRITE: lock 0x%08x (dir %ld/%ld pos %ld) want %ld\n",
 250                       pkt->dp_Arg1,
 251                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0,
 252                       fl->pos,
 253                       want));
 254
 255                 if ((err = TestLock(fl))) {
 256                     res = -1;
 257                     break;
 258                 }
 259
 260                 if ((err = OpWrite(fl, buffer, want, &res)) != 0)
 261                     res = -1;
 262
 263                 break;
 264             }
 265
 266             case ACTION_SEEK: {
 267                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1);
 268                 LONG offset = pkt->dp_Arg2;
 269                 ULONG whence = pkt->dp_Arg3;
 270
 271                 D(bug("[fat] SEEK: lock 0x%08x (dir %ld/%ld pos %ld) offset %ld whence %s\n",
 272                       pkt->dp_Arg1,
 273                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0,
 274                       fl->pos,
 275                       offset,
 276                       whence == OFFSET_BEGINNING ? "BEGINNING" :
 277                       whence == OFFSET_END       ? "END"       :
 278                       whence == OFFSET_CURRENT   ? "CURRENT"   :
 279                                                    "(unknown)"));
 280
 281                 if ((err = TestLock(fl))) {
 282                     res = -1;
 283                     break;
 284                 }
 285
 286                 res = fl->pos;
 287                 err = 0;
 288
 289                 if (whence == OFFSET_BEGINNING &&
 290                     offset >= 0 &&
 291                     offset <= fl->gl->size)
 292                     fl->pos = offset;
 293                 else if (whence == OFFSET_CURRENT &&
 294                          offset + fl->pos >= 0 &&
 295                          offset + fl->pos <= fl->gl->size)
 296                     fl->pos += offset;
 297                 else if (whence == OFFSET_END
 298                          && offset <= 0
 299                          && fl->gl->size + offset >= 0)
 300                     fl->pos = fl->gl->size + offset;
 301                 else {
 302                     res = -1;
 303                     err = ERROR_SEEK_ERROR;
 304                 }
 305
 306                 break;
 307             }
 308
 309             case ACTION_SET_FILE_SIZE: {
 310                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1);
 311                 LONG offset = pkt->dp_Arg2;
 312                 LONG whence = pkt->dp_Arg3;
 313
 314                 D(bug("[fat] SET_FILE_SIZE: lock 0x%08x (dir %ld/%ld pos %ld) offset %ld whence %s\n",
 315                       pkt->dp_Arg1,
 316                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0,
 317                       fl->pos,
 318                       offset,
 319                       whence == OFFSET_BEGINNING ? "BEGINNING" :
 320                       whence == OFFSET_END       ? "END"       :
 321                       whence == OFFSET_CURRENT   ? "CURRENT"   :
 322                                                    "(unknown)"));
 323
 324                 if ((err = TestLock(fl))) {
 325                     res = -1;
 326                     break;
 327                 }
 328
 329                 if ((err = OpSetFileSize(fl, offset, whence, &res)) != 0)
 330                     res = -1;
 331
 332                 break;
 333             }
 334
 335             case ACTION_END: {
 336                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1);
 337
 338                 D(bug("[fat] END: lock 0x%08x (dir %ld/%ld)\n",
 339                       pkt->dp_Arg1,
 340                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0));
 341
 342                 if ((err = TestLock(fl)))
 343                     break;
 344
 345                 FreeLock(fl);
 346
 347                 res = DOSTRUE;
 348                 break;
 349             }
 350
 351             case ACTION_IS_FILESYSTEM:
 352                 D(bug("[fat] IS_FILESYSTEM\n"));
 353
 354                 res = DOSTRUE;
 355                 break;
 356
 357             case ACTION_CURRENT_VOLUME: {
 358                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1);
 359
 360                 D(bug("[fat] CURRENT_VOLUME: lock 0x%08x\n",
 361                       pkt->dp_Arg1));
 362
 363                 res = (LONG)((fl) ? fl->fl_Volume : ((glob->sb != NULL) ? MKBADDR(glob->sb->doslist) : NULL));
 364                 break;
 365             }
 366
 367             case ACTION_INFO:
 368             case ACTION_DISK_INFO: {
 369                 struct InfoData *id;
 370
 371                 if (pkt->dp_Type == ACTION_INFO) {
 372                     struct FileLock *fl = BADDR(pkt->dp_Arg1);
 373
 374                     D(bug("[fat] INFO: lock 0x%08x\n",
 375                           pkt->dp_Arg1));
 376
 377                     if (fl && (glob->sb == NULL || fl->fl_Volume != MKBADDR(glob->sb->doslist))) {
 378                         err = ERROR_DEVICE_NOT_MOUNTED;
 379                         break;
 380                     }
 381
 382                     id = BADDR(pkt->dp_Arg2);
 383                 }
 384                 else {
 385                     D(bug("[fat] DISK_INFO\n"));
 386
 387                     id = BADDR(pkt->dp_Arg1);
 388                 }
 389
 390                 FillDiskInfo(id);
 391
 392                 res = DOSTRUE;
 393                 break;
 394             }
 395
 396             case ACTION_INHIBIT: {
 397                 LONG inhibit = pkt->dp_Arg1;
 398
 399                 D(bug("[fat] INHIBIT: %sinhibit\n",
 400                     inhibit == DOSTRUE ? "" : "un"));
 401
 402                 if (inhibit == DOSTRUE) {
 403                     glob->disk_inhibited++;
 404                     if (glob->disk_inhibited == 1)
 405                         DoDiskRemove();
 406                 }
 407                 else if (glob->disk_inhibited) {
 408                     glob->disk_inhibited--;
 409                     if (glob->disk_inhibited == 0)
 410                        ProcessDiskChange();
 411                 }
 412
 413                 res = DOSTRUE;
 414                 break;
 415             }
 416
 417             case ACTION_DIE: {
 418                 D(bug("[fat] DIE\n"));
 419
 420                 if (glob->sblist != NULL || (glob->sb != NULL && glob->sb->doslist->dol_misc.dol_volume.dol_LockList != NULL)) {
 421                     D(bug("\tThere are some locks/volumes left. Shutting down is not possible\n"));
 422                     err = ERROR_OBJECT_IN_USE;
 423                     break;
 424                 }
 425
 426                 D(bug("\tNo locks pending. Shutting down the handler\n"));
 427
 428                 DoDiskRemove(); /* risky, because of async. volume remove, but works */
 429
 430                 glob->quit = TRUE;
 431                 glob->devnode->dol_Task = NULL;
 432
 433                 res = DOSTRUE;
 434                 break;
 435             }
 436
 437 #if 0
 438             /* XXX AROS needs these ACTION_ headers defined in dos/dosextens.h */
 439
 440             case ACTION_GET_DISK_FSSM: {
 441                 D(bug("\nGot ACTION_GET_DISK_FSSM\n"));
 442
 443                 res = (ULONG) glob->fssm;
 444                 break;
 445             }
 446
 447             case ACTION_FREE_DISK_FSSM: {
 448                 D(bug("\nGot ACTION_FREE_DISK_FSSM\n"));
 449
 450                 res = DOSTRUE;
 451                 break;
 452
 453             }
 454 #endif
 455
 456             case ACTION_DISK_CHANGE: { /* internal */
 457                 struct DosList *vol = (struct DosList *)pkt->dp_Arg2;
 458                 ULONG type = pkt->dp_Arg3;
 459
 460                 D(bug("[fat] DISK_CHANGE [INTERNAL]\n"));
 461
 462                 if (pkt->dp_Arg1 == ID_FAT_DISK) { /* security check */
 463
 464                     if (AttemptLockDosList(LDF_VOLUMES|LDF_WRITE)) {
 465
 466                         if (type == ACTION_VOLUME_ADD) {
 467                             AddDosEntry(vol);
 468                             UnLockDosList(LDF_VOLUMES|LDF_WRITE);
 469
 470                             SendEvent(IECLASS_DISKINSERTED);
 471
 472                             D(bug("\tVolume added successfuly\n"));
 473                         }
 474                         else if (type == ACTION_VOLUME_REMOVE) {
 475                             RemDosEntry(vol);
 476                             FreeVecPooled(glob->mempool, vol);
 477                             UnLockDosList(LDF_VOLUMES|LDF_WRITE);
 478
 479                             SendEvent(IECLASS_DISKREMOVED);
 480
 481                             D(bug("\tVolume removed successfuly.\n"));
 482                         }
 483
 484                         FreeDosObject(DOS_STDPKT, pkt); /* cleanup */
 485
 486                         pkt = NULL;
 487                         D(bug("Packet destroyed\n"));
 488                     }
 489
 490                     else {
 491                         D(bug("\tDosList is locked\n"));
 492                         Delay(5);
 493                         PutMsg(glob->ourport, pkt->dp_Link);
 494                         pkt = NULL;
 495                         D(bug("Message moved to the end of the queue\n"));
 496                     }
 497                 }
 498                 else
 499                     err = ERROR_OBJECT_WRONG_TYPE;
 500
 501                 break;
 502             }
 503
 504             case ACTION_RENAME_DISK: {
 505                 UBYTE *name = BADDR(pkt->dp_Arg1);
 506
 507                 D(bug("[fat] RENAME_DISK: name '"); RawPutChars(&name[1], name[0]); bug("'\n"));
 508
 509                 if (glob->sb->doslist == NULL) {
 510                     err = glob->disk_inserted ? ERROR_NOT_A_DOS_DISK : ERROR_NO_DISK;
 511                     break;
 512                 }
 513
 514                 while (! AttemptLockDosList(LDF_VOLUMES | LDF_WRITE))
 515                     ProcessPackets();
 516
 517                 err = SetVolumeName(glob->sb, name);
 518                 UnLockDosList(LDF_VOLUMES | LDF_WRITE);
 519                 if (err != 0)
 520                     break;
 521
 522                 SendEvent(IECLASS_DISKINSERTED);
 523
 524                 res = DOSTRUE;
 525
 526                 break;
 527             }
 528
 529             case ACTION_DELETE_OBJECT: {
 530                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1);
 531                 UBYTE *name = BADDR(pkt->dp_Arg2);
 532
 533                 D(bug("[fat] DELETE_OBJECT: lock 0x%08x (dir %ld/%ld) path '",
 534                       pkt->dp_Arg1,
 535                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0);
 536                   RawPutChars(&name[1], name[0]); bug("'\n"));
 537
 538                 if ((err = TestLock(fl)))
 539                     break;
 540
 541                 err = OpDeleteFile(fl, &name[1], name[0]);
 542
 543                 break;
 544             }
 545
 546             case ACTION_RENAME_OBJECT: {
 547                 struct ExtFileLock *sfl = BADDR(pkt->dp_Arg1), *dfl = BADDR(pkt->dp_Arg3);
 548                 UBYTE *sname = BADDR(pkt->dp_Arg2), *dname = BADDR(pkt->dp_Arg4);
 549
 550                 D(bug("[fat] RENAME_OBJECT: srclock 0x%08x (dir %ld/%ld) name '",
 551                       pkt->dp_Arg1,
 552                       sfl != NULL ? sfl->gl->dir_cluster : 0, sfl != NULL ? sfl->gl->dir_entry : 0);
 553                   RawPutChars(&sname[1], sname[0]); bug("' destlock 0x%08x (dir %ld/%ld) name '",
 554                       pkt->dp_Arg3,
 555                       dfl != NULL ? dfl->gl->dir_cluster : 0, dfl != NULL ? dfl->gl->dir_entry : 0);
 556                   RawPutChars(&dname[1], dname[0]); bug("'\n"));
 557
 558                 if ((err = TestLock(sfl)) != 0 || (err = TestLock(dfl)) != 0)
 559                     break;
 560
 561                 err = OpRenameFile(sfl, &sname[1], sname[0], dfl, &dname[1], dname[0]);
 562
 563                 break;
 564             }
 565
 566             case ACTION_CREATE_DIR: {
 567                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg1), *new;
 568                 UBYTE *name = BADDR(pkt->dp_Arg2);
 569
 570                 D(bug("[fat] CREATE_DIR: lock 0x%08x (dir %ld/%ld) name '",
 571                       pkt->dp_Arg1,
 572                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0);
 573                   RawPutChars(&name[1], name[0]); bug("'\n"));
 574
 575                 if ((err = TestLock(fl)))
 576                     break;
 577
 578                 if ((err = OpCreateDir(fl, &name[1], name[0], &new)) == 0)
 579                     res = (LONG)MKBADDR(new);
 580
 581                 break;
 582             }
 583
 584             case ACTION_SET_PROTECT: {
 585                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg2);
 586                 UBYTE *name = BADDR(pkt->dp_Arg3);
 587                 ULONG prot = pkt->dp_Arg4;
 588
 589                 D(bug("[fat] SET_PROTECT: lock 0x%08x (dir %ld/%ld) name '", pkt->dp_Arg2,
 590                       fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0);
 591                   RawPutChars(&name[1], name[0]); bug("' prot 0x%08x\n", prot));
 592                 if ((err = TestLock(fl)))
 593                     break;
 594
 595                 err = OpSetProtect(fl, &name[1], name[0], prot);
 596
 597                 break;
 598             }
 599
 600             case ACTION_SET_DATE: {
 601                 struct ExtFileLock *fl = BADDR(pkt->dp_Arg2);
 602                 UBYTE *name = BADDR(pkt->dp_Arg3);
 603                 struct DateStamp *ds = (struct DateStamp *)pkt->dp_Arg4;
 604
 605 #if defined(DEBUG) && DEBUG != 0
 606                 {
 607                     struct DateTime dt;
 608                     char datestr[LEN_DATSTRING];
 609
 610                     dt.dat_Stamp = *ds;
 611                     dt.dat_Format = FORMAT_DOS;
 612                     dt.dat_Flags = 0;
 613                     dt.dat_StrDay = NULL;
 614                     dt.dat_StrDate = datestr;
 615                     dt.dat_StrTime = NULL;
 616                     DateToStr(&dt);
 617
 618                     D(bug("[fat] SET_DATE: lock 0x%08x (dir %ld/%ld) name '",
 619                           pkt->dp_Arg2,
 620                           fl != NULL ? fl->gl->dir_cluster : 0, fl != NULL ? fl->gl->dir_entry : 0);
 621                       RawPutChars(&name[1], name[0]); bug("' ds '%s'\n", datestr));
 622                 }
 623 #endif
 624
 625                 if ((err = TestLock(fl)))
 626                     break;
 627
 628                 err = OpSetDate(fl, &name[1], name[0], ds);
 629
 630                 break;
 631             }
 632
 633             case ACTION_ADD_NOTIFY: {
 634                 struct NotifyRequest *nr = (struct NotifyRequest *)pkt->dp_Arg1;
 635
 636                 D(bug("[fat] ADD_NOTIFY: nr 0x%08x name '%s'\n", nr, nr->nr_FullName));
 637
 638                 err = OpAddNotify(nr);
 639
 640                 break;
 641             }
 642
 643             case ACTION_REMOVE_NOTIFY: {
 644                 struct NotifyRequest *nr = (struct NotifyRequest *)pkt->dp_Arg1;
 645
 646                 D(bug("[fat] REMOVE_NOTIFY: nr 0x%08x name '%s'\n", nr, nr->nr_FullName));
 647
 648                 err = OpRemoveNotify(nr);
 649
 650                 break;
 651             }
 652
 653             default:
 654                 D(bug("[fat] got unknown packet type %ld\n", pkt->dp_Type));
 655
 656                 err = ERROR_ACTION_NOT_KNOWN;
 657         }
 658
 659         if (pkt != NULL) {
 660             D(bug("[fat] replying to packet: result 0x%x, error 0x%x\n", res, err));
 661
 662             rp = pkt->dp_Port;
 663
 664             pkt->dp_Port = glob->ourport;
 665             pkt->dp_Res1 = res;
 666             pkt->dp_Res2 = err;
 667
 668             PutMsg(rp, pkt->dp_Link);
 669         }
 670
 671 #if defined(DEBUG_CACHESTATS) && DEBUG_CACHESTATS != 0
 672         cache_stats(glob->sb->cache);
 673 #endif
 674     }
 675 }