rom/filesys/ram/commands.c

   1 /*
   2
   3 File: commands.c
   4 Author: Neil Cafferkey
   5 Copyright (C) 2001-2008 Neil Cafferkey
   6
   7 This file is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU Lesser General Public License as
   9 published by the Free Software Foundation; either version 2.1 of the
  10 License, or (at your option) any later version.
  11
  12 This file is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15 Lesser General Public License for more details.
  16
  17 You should have received a copy of the GNU Lesser General Public
  18 License along with this file; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  20 MA 02111-1307, USA.
  21
  22 */
  23
  24 #include <aros/config.h>
  25 #include <aros/debug.h>
  26
  27 #include "handler_protos.h"
  28
  29
  30 static const TEXT default_vol_name[] = "RAM Disk";
  31
  32
  33 static const UWORD examine_sizes[] =
  34 {
  35    (UWORD)OFFSET(ExAllData, ed_Type),
  36    (UWORD)OFFSET(ExAllData, ed_Size),
  37    (UWORD)OFFSET(ExAllData, ed_Prot),
  38    (UWORD)OFFSET(ExAllData, ed_Days),
  39    (UWORD)OFFSET(ExAllData, ed_Comment),
  40    (UWORD)OFFSET(ExAllData, ed_OwnerUID)
  41 };
  42
  43
  44
  45 /****i* ram.handler/CmdStartup *********************************************
  46 *
  47 *   NAME
  48 *       CmdStartup --
  49 *
  50 *   SYNOPSIS
  51 *       handler = CmdStartup(name, dev_node,
  52 *           proc_port)
  53 *
  54 *       struct Handler *CmdStartup(STRPTR, struct DeviceNode *,
  55 *           struct MsgPort *);
  56 *
  57 *   FUNCTION
  58 *
  59 *   INPUTS
  60 *
  61 *   RESULT
  62 *
  63 *   EXAMPLE
  64 *
  65 *   NOTES
  66 *
  67 *   BUGS
  68 *
  69 *   SEE ALSO
  70 *
  71 ****************************************************************************
  72 *
  73 */
  74
  75 BOOL CmdStartup(struct Handler *handler, STRPTR name, struct DeviceNode *dev_node,
  76    struct MsgPort *proc_port)
  77 {
  78    struct DosList *volume;
  79    struct Object *root_dir;
  80    struct MsgPort *port;
  81    LONG error;
  82    APTR base;
  83
  84    /* Open extra libraries */
  85
  86    error = 0;
  87    base = OpenLibrary(UTILITYNAME, UTILITY_VERSION);
  88    if(base != NULL)
  89       UtilityBase = base;
  90    else
  91       error = 1;
  92
  93 #if !(AROS_FLAVOUR & AROS_FLAVOUR_BINCOMPAT)
  94    base = OpenLibrary("locale.library", LOCALE_VERSION);
  95    if(base != NULL)
  96       LocaleBase = base;
  97    else
  98       error = 1;
  99 #endif
 100
 101    /* Initialise private handler structure */
 102
 103    if(error == 0)
 104    {
 105       handler->proc_port = proc_port;
 106       handler->block_count = MEMBLOCKS(StrSize(default_vol_name)) +
 107          MEMBLOCKS(sizeof(struct Handler));
 108       handler->min_block_size = MIN_BLOCK_SIZE;
 109       handler->max_block_size = MAX_BLOCK_SIZE;
 110       NewList((APTR)&handler->examinations);
 111
 112       dev_node->dn_Task = proc_port;
 113
 114       /* Create pools for zeroed, non-zeroed and public zeroed memory */
 115
 116       handler->clear_pool = CreatePool(MEMF_CLEAR, CLEAR_PUDDLE_SIZE,
 117          CLEAR_PUDDLE_THRESH);
 118       if(handler->clear_pool == NULL)
 119          error = IoErr();
 120       handler->muddy_pool = CreatePool(MEMF_ANY, MUDDY_PUDDLE_SIZE,
 121          MUDDY_PUDDLE_THRESH);
 122       if(handler->muddy_pool == NULL)
 123          error = IoErr();
 124       handler->public_pool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR,
 125          PUBLIC_PUDDLE_SIZE, PUBLIC_PUDDLE_THRESH);
 126       if(handler->public_pool == NULL)
 127          error = IoErr();
 128
 129       /* Create a volume dos node */
 130
 131       volume = MyMakeDosEntry(handler, default_vol_name, DLT_VOLUME);
 132       if(volume == NULL)
 133          error = IoErr();
 134    }
 135
 136    if(error == 0)
 137    {
 138       volume->dol_Task = proc_port;
 139       DateStamp(&volume->dol_misc.dol_volume.dol_VolumeDate);
 140       volume->dol_misc.dol_volume.dol_DiskType = ID_DOS_DISK;
 141
 142       /* Put volume node into dos list */
 143
 144       AddDosEntry(volume);
 145       handler->volume = volume;
 146
 147       /* Open default locale */
 148       if (LocaleBase)
 149           handler->locale = OpenLocale(NULL);
 150
 151       /* Initialise notification handling */
 152
 153       NewList((APTR)&handler->notifications);
 154       port = CreateMsgPort();
 155       handler->notify_port = port;
 156       if(port == NULL)
 157          error = IoErr();
 158    }
 159
 160    /* Create the root directory and get a shared lock on it */
 161
 162    if(error == 0)
 163    {
 164       root_dir = CreateObject(handler, default_vol_name, ST_ROOT, NULL);
 165       handler->root_dir = root_dir;
 166       if(root_dir != NULL)
 167       {
 168          if(LockObject(handler, root_dir, ACCESS_READ) == NULL)
 169             error = IoErr();
 170       }
 171       else
 172          error = IoErr();
 173    }
 174
 175    /* Return result */
 176
 177    SetIoErr(error);
 178    return error != 0;
 179 }
 180
 181
 182
 183 /****i* ram.handler/CmdDie *************************************************
 184 *
 185 *   NAME
 186 *       CmdDie --
 187 *
 188 *   SYNOPSIS
 189 *       success = CmdDie(handler)
 190 *
 191 *       BOOL CmdDie(struct Handler *);
 192 *
 193 *   FUNCTION
 194 *
 195 *   INPUTS
 196 *
 197 *   RESULT
 198 *
 199 *   EXAMPLE
 200 *
 201 *   NOTES
 202 *
 203 *   BUGS
 204 *
 205 *   SEE ALSO
 206 *
 207 ****************************************************************************
 208 *
 209 */
 210
 211 BOOL CmdDie(struct Handler *handler)
 212 {
 213    struct Object *root_dir;
 214    LONG error = 0;
 215
 216    root_dir = handler->root_dir;
 217    if(IsListEmpty(&root_dir->elements)
 218       && IsListEmpty(&handler->notifications)
 219       && IsListEmpty(&root_dir->notifications)
 220       && root_dir->lock->lock_count == 1)
 221       DeleteHandler(handler);
 222    else
 223       error = ERROR_OBJECT_IN_USE;
 224
 225    /* Return success indicator */
 226
 227    SetIoErr(error);
 228    return error == 0;
 229 }
 230
 231
 232
 233 /****i* ram.handler/CmdIsFileSystem ****************************************
 234 *
 235 *   NAME
 236 *       CmdIsFileSystem --
 237 *
 238 *   SYNOPSIS
 239 *       result = CmdIsFileSystem()
 240 *
 241 *       BOOL CmdIsFileSystem();
 242 *
 243 *   FUNCTION
 244 *
 245 *   INPUTS
 246 *
 247 *   RESULT
 248 *
 249 *   EXAMPLE
 250 *
 251 *   NOTES
 252 *
 253 *   BUGS
 254 *
 255 *   SEE ALSO
 256 *
 257 ****************************************************************************
 258 *
 259 */
 260
 261 BOOL CmdIsFileSystem()
 262 {
 263    return TRUE;
 264 }
 265
 266
 267
 268 /****i* ram.handler/CmdFind ************************************************
 269 *
 270 *   NAME
 271 *       CmdFind --
 272 *
 273 *   SYNOPSIS
 274 *       success = CmdFind(handler, handle, lock,
 275 *           name, mode)
 276 *
 277 *       BOOL CmdFind(struct Handler *, struct FileHandle *, struct Lock *,
 278 *           TEXT *, ULONG);
 279 *
 280 *   FUNCTION
 281 *
 282 *   INPUTS
 283 *
 284 *   RESULT
 285 *
 286 *   EXAMPLE
 287 *
 288 *   NOTES
 289 *
 290 *   BUGS
 291 *
 292 *   SEE ALSO
 293 *
 294 ****************************************************************************
 295 *
 296 */
 297
 298 BOOL CmdFind(struct Handler *handler, struct FileHandle *handle,
 299    struct Lock *lock, const TEXT *name, ULONG type)
 300 {
 301    LONG error = 0;
 302    ULONG mode;
 303    struct Object *file, *parent;
 304
 305    /* Set access mode */
 306
 307    if(type == MODE_NEWFILE)
 308       mode = ACCESS_WRITE;
 309    else
 310       mode = ACCESS_READ;
 311
 312    /* Get file */
 313
 314    if(type == MODE_NEWFILE && handler->locked)
 315       error = ERROR_DISK_WRITE_PROTECTED;
 316
 317    if(error == 0)
 318    {
 319       file = GetHardObject(handler, lock, name, &parent);
 320       if(parent == NULL)
 321          error = IoErr();
 322    }
 323
 324    /* Do any necessary file deletion or creation */
 325
 326    if(error == 0)
 327    {
 328       name = FilePart(name);
 329
 330       switch(type)
 331       {
 332       case MODE_NEWFILE:
 333          if(file != NULL)
 334          {
 335             if((GetRealObject(file)->protection & FIBF_DELETE) != 0)
 336                error = ERROR_DELETE_PROTECTED;
 337
 338             if(((struct Node *)file)->ln_Pri >= 0)
 339                error = ERROR_OBJECT_EXISTS;
 340          }
 341
 342          if(error == 0)
 343          {
 344             if(!AttemptDeleteObject(handler, file, FALSE))
 345                error = IoErr();
 346             file = NULL;
 347          }
 348
 349       case MODE_READWRITE:
 350          if(error == 0 && file == NULL)
 351             file = CreateObject(handler, name, ST_FILE, parent);
 352
 353       default:
 354          if(file == NULL)
 355             error = IoErr();
 356       }
 357    }
 358
 359    /* Get a lock on the file */
 360
 361    if(error == 0)
 362    {
 363       lock = LockObject(handler, file, mode);
 364       if(lock == NULL)
 365          error = IoErr();
 366       else if(type == MODE_NEWFILE)
 367          lock->changed = TRUE;
 368    }
 369
 370    /* Open file */
 371
 372    if(error == 0)
 373    {
 374       if(!CmdFHFromLock(handler, handle, lock))
 375       {
 376          error = IoErr();
 377          CmdFreeLock(handler, lock);
 378       }
 379    }
 380
 381    /* Set error and return success code */
 382
 383    SetIoErr(error);
 384    return error == 0;
 385 }
 386
 387
 388
 389 /****i* ram.handler/CmdFHFromLock ******************************************
 390 *
 391 *   NAME
 392 *       CmdFHFromLock --
 393 *
 394 *   SYNOPSIS
 395 *       success = CmdFHFromLock(handle, lock)
 396 *
 397 *       BOOL CmdFHFromLock(struct FileHandle *, struct Lock *);
 398 *
 399 *   FUNCTION
 400 *
 401 *   INPUTS
 402 *
 403 *   RESULT
 404 *
 405 *   EXAMPLE
 406 *
 407 *   NOTES
 408 *
 409 *   BUGS
 410 *
 411 *   SEE ALSO
 412 *
 413 ****************************************************************************
 414 *
 415 */
 416
 417 BOOL CmdFHFromLock(struct Handler *handler, struct FileHandle *handle,
 418    struct Lock *lock)
 419 {
 420    LONG error = 0;
 421    struct Opening *opening = NULL;
 422    struct Object *file;
 423
 424    /* Check if access is allowed */
 425
 426    file = (APTR)((struct FileLock *)lock)->fl_Key;
 427    if(((struct Node *)file)->ln_Pri != ST_FILE)
 428       error = ERROR_OBJECT_WRONG_TYPE;
 429
 430    /* Create and initialise "opening" */
 431
 432    if(error == 0)
 433    {
 434       opening = AllocPooled(handler->clear_pool, sizeof(struct Opening));
 435       if(opening != NULL)
 436       {
 437          opening->file = file;
 438          opening->block = (struct Block *)file->elements.mlh_Head;
 439          AddTail((struct List *)&lock->openings, (struct Node *)opening);
 440       }
 441       else
 442          error = IoErr();
 443    }
 444
 445    /* Put address of opening in file handle */
 446
 447    handle->fh_Arg1 = (PINT)opening;
 448
 449    /* Set error and return success code */
 450
 451    SetIoErr(error);
 452    return error == 0;
 453 }
 454
 455
 456
 457 /****i* ram.handler/CmdEnd *************************************************
 458 *
 459 *   NAME
 460 *       CmdEnd --
 461 *
 462 *   SYNOPSIS
 463 *       success = CmdEnd(handler, opening)
 464 *
 465 *       BOOL CmdEnd(struct Handler *, struct Opening *);
 466 *
 467 *   FUNCTION
 468 *
 469 *   INPUTS
 470 *
 471 *   RESULT
 472 *
 473 *   EXAMPLE
 474 *
 475 *   NOTES
 476 *
 477 *   BUGS
 478 *
 479 *   SEE ALSO
 480 *
 481 ****************************************************************************
 482 *
 483 */
 484
 485 BOOL CmdEnd(struct Handler *handler, struct Opening *opening)
 486 {
 487    struct Object *file, *parent;
 488    struct Lock *lock;
 489    LONG error = 0;
 490
 491    /* Close file and update its date and flags */
 492
 493    file = opening->file;
 494    lock = file->lock;
 495    if(lock->changed)
 496    {
 497       if(!handler->locked)
 498       {
 499          file->protection &= ~FIBF_ARCHIVE;
 500          DateStamp(&file->date);
 501          parent = file->parent;
 502          parent->protection &= ~FIBF_ARCHIVE;
 503          CopyMem(&file->date, &parent->date, sizeof(struct DateStamp));
 504
 505          NotifyAll(handler, file, TRUE);
 506       }
 507       else
 508          error = ERROR_DISK_WRITE_PROTECTED;
 509    }
 510
 511    if(error == 0)
 512    {
 513       Remove((APTR)opening);
 514       CmdFreeLock(handler, lock);
 515       FreePooled(handler->clear_pool, opening, sizeof(struct Opening));
 516    }
 517
 518    /* Return success indicator */
 519
 520    SetIoErr(error);
 521    return error == 0;
 522 }
 523
 524
 525
 526 /****i* ram.handler/CmdRead ************************************************
 527 *
 528 *   NAME
 529 *       CmdRead --
 530 *
 531 *   SYNOPSIS
 532 *       actual_length = CmdRead(opening, buffer, length)
 533 *
 534 *       UPINT CmdRead(struct Opening *, UBYTE *, UPINT);
 535 *
 536 *   FUNCTION
 537 *
 538 *   INPUTS
 539 *
 540 *   RESULT
 541 *
 542 *   EXAMPLE
 543 *
 544 *   NOTES
 545 *
 546 *   BUGS
 547 *
 548 *   SEE ALSO
 549 *
 550 ****************************************************************************
 551 *
 552 */
 553
 554 UPINT CmdRead(struct Handler *handler, struct Opening *opening, UBYTE *buffer, UPINT length)
 555 {
 556    LONG error = 0;
 557    struct Object *file;
 558
 559    /* Read file if it isn't read protected */
 560
 561    file = opening->file;
 562
 563    if((file->protection & FIBF_READ) != 0)
 564       error = ERROR_READ_PROTECTED;
 565
 566    if(error == 0)
 567    {
 568       length = ReadData(opening, buffer, length);
 569       error = IoErr();
 570    }
 571    else
 572    {
 573       length = -1;
 574    }
 575
 576    /* Return number of bytes read */
 577
 578    SetIoErr(error);
 579    return length;
 580 }
 581
 582
 583
 584 /****i* ram.handler/CmdWrite ***********************************************
 585 *
 586 *   NAME
 587 *       CmdWrite --
 588 *
 589 *   SYNOPSIS
 590 *       actual_length = CmdWrite(handler, opening, buffer, length)
 591 *
 592 *       UPINT CmdWrite(struct Handler *, struct Opening *, UBYTE *, UPINT);
 593 *
 594 *   FUNCTION
 595 *
 596 *   INPUTS
 597 *
 598 *   RESULT
 599 *
 600 *   EXAMPLE
 601 *
 602 *   NOTES
 603 *
 604 *   BUGS
 605 *
 606 *   SEE ALSO
 607 *
 608 ****************************************************************************
 609 *
 610 */
 611
 612 UPINT CmdWrite(struct Handler *handler, struct Opening *opening,
 613    UBYTE *buffer, UPINT length)
 614 {
 615    LONG error = 0;
 616    struct Object *file;
 617    struct Lock *lock;
 618
 619    /* Write to file if it isn't write protected */
 620
 621    file = opening->file;
 622    lock = file->lock;
 623
 624    if((file->protection & FIBF_WRITE) != 0)
 625       error = ERROR_WRITE_PROTECTED;
 626
 627    if(handler->locked)
 628       error = ERROR_DISK_WRITE_PROTECTED;
 629
 630    if(error == 0)
 631    {
 632       length = WriteData(handler, opening, buffer, length);
 633       error = IoErr();
 634       if(length > 0)
 635          lock->changed = TRUE;
 636    }
 637    else
 638    {
 639       length = -1;
 640    }
 641
 642    /* Return number of bytes written */
 643
 644    SetIoErr(error);
 645    return length;
 646 }
 647
 648
 649
 650 /****i* ram.handler/CmdSeek ************************************************
 651 *
 652 *   NAME
 653 *       CmdSeek --
 654 *
 655 *   SYNOPSIS
 656 *       old_pos = CmdSeek(opening, offset, mode)
 657 *
 658 *       PINT CmdSeek(struct Opening *, PINT, LONG);
 659 *
 660 *   FUNCTION
 661 *
 662 *   INPUTS
 663 *
 664 *   RESULT
 665 *
 666 *   EXAMPLE
 667 *
 668 *   NOTES
 669 *
 670 *   BUGS
 671 *
 672 *   SEE ALSO
 673 *
 674 ****************************************************************************
 675 *
 676 */
 677
 678 UPINT CmdSeek(struct Handler *handler, struct Opening *opening, PINT offset, LONG mode)
 679 {
 680    struct Block *block;
 681    struct Object *file;
 682    UPINT block_pos, block_length, remainder, old_pos, new_pos;
 683
 684    /* Get starting point */
 685
 686    file = opening->file;
 687    old_pos = opening->pos;
 688
 689    if(mode == OFFSET_BEGINNING)
 690    {
 691       block = (APTR)file->elements.mlh_Head;
 692       new_pos = block_pos = 0;
 693    }
 694    else if(mode == OFFSET_CURRENT)
 695    {
 696       block = opening->block;
 697       block_pos = opening->block_pos;
 698       new_pos = old_pos;
 699    }
 700    else
 701    {
 702       block = (APTR)file->elements.mlh_TailPred;
 703       block_pos = file->end_length;
 704       new_pos = file->length;
 705    }
 706
 707    /* Check new position is within file */
 708
 709    new_pos += offset;
 710    if(new_pos > file->length)
 711    {
 712       SetIoErr(ERROR_SEEK_ERROR);
 713       return -1;
 714    }
 715
 716    if(offset >= 0)
 717    {
 718       /* Go forwards */
 719
 720       block_length = GetBlockLength(file, block);
 721       remainder = offset + block_pos;
 722       while(remainder > block_length)
 723       {
 724          remainder -= block_length;
 725          block = (APTR)((struct MinNode *)block)->mln_Succ;
 726          block_length = GetBlockLength(file, block);
 727       }
 728
 729       block_pos = remainder;
 730    }
 731    else
 732    {
 733       /* Go backwards */
 734
 735       block_length = block_pos;
 736       remainder = -offset;
 737       while(remainder >= block_length && remainder > 0)
 738       {
 739          remainder -= block_length;
 740          block = (APTR)((struct MinNode *)block)->mln_Pred;
 741          block_length = GetBlockLength(file, block);
 742       }
 743
 744       block_pos = block_length - remainder;
 745    }
 746
 747    /* Record new position for next access */
 748
 749    opening->block = block;
 750    opening->block_pos = block_pos;
 751    opening->pos = new_pos;
 752
 753    /* Return old position */
 754
 755    return old_pos;
 756 }
 757
 758
 759
 760 /****i* ram.handler/CmdSetFileSize *****************************************
 761 *
 762 *   NAME
 763 *       CmdSetFileSize --
 764 *
 765 *   SYNOPSIS
 766 *       new_length = CmdSetFileSize(handler, opening, offset, mode)
 767 *
 768 *       PINT CmdSetFileSize(struct Handler *, struct Opening *, PINT, LONG);
 769 *
 770 *   FUNCTION
 771 *
 772 *   INPUTS
 773 *
 774 *   RESULT
 775 *
 776 *   EXAMPLE
 777 *
 778 *   NOTES
 779 *
 780 *   BUGS
 781 *
 782 *   SEE ALSO
 783 *
 784 ****************************************************************************
 785 *
 786 */
 787
 788 PINT CmdSetFileSize(struct Handler *handler, struct Opening *opening,
 789    PINT offset, LONG mode)
 790 {
 791    LONG error = 0, new_size;
 792    struct Object *file;
 793    struct Lock *lock;
 794
 795    /* Change file size if it's open for writing */
 796
 797    file = opening->file;
 798    lock = file->lock;
 799
 800    if((file->protection & FIBF_WRITE) != 0)
 801       error = ERROR_WRITE_PROTECTED;
 802    if(handler->locked)
 803       error = ERROR_DISK_WRITE_PROTECTED;
 804
 805    if(error == 0)
 806    {
 807       new_size = ChangeFileSize(handler, opening, offset, mode);
 808       if(new_size == -1)
 809          error = IoErr();
 810       else
 811          lock->changed = TRUE;
 812    }
 813    else
 814       new_size = -1;
 815
 816    /* Return new file size */
 817
 818    SetIoErr(error);
 819    return new_size;
 820 }
 821
 822
 823
 824 /****i* ram.handler/CmdLocateObject ****************************************
 825 *
 826 *   NAME
 827 *       CmdLocateObject --
 828 *
 829 *   SYNOPSIS
 830 *       lock = CmdLocateObject(handler, lock,
 831 *           name, mode)
 832 *
 833 *       struct Lock *CmdLocateObject(struct Handler *, struct Lock *,
 834 *           TEXT *, ULONG);
 835 *
 836 *   FUNCTION
 837 *
 838 *   INPUTS
 839 *
 840 *   RESULT
 841 *
 842 *   EXAMPLE
 843 *
 844 *   NOTES
 845 *
 846 *   BUGS
 847 *
 848 *   SEE ALSO
 849 *
 850 ****************************************************************************
 851 *
 852 */
 853
 854 struct Lock *CmdLocateObject(struct Handler *handler, struct Lock *lock,
 855    const TEXT *name, ULONG mode)
 856 {
 857    struct Object *object;
 858
 859    /* Find the object and lock it */
 860
 861    object = GetHardObject(handler, lock, name, NULL);
 862
 863    if(object != NULL)
 864       lock = LockObject(handler, object, mode);
 865    else
 866       lock = NULL;
 867
 868    /* Return result */
 869
 870    return lock;
 871 }
 872
 873
 874
 875 /****i* ram.handler/CmdFreeLock ********************************************
 876 *
 877 *   NAME
 878 *       CmdFreeLock --
 879 *
 880 *   SYNOPSIS
 881 *       success = CmdFreeLock(handler, lock)
 882 *
 883 *       BOOL CmdFreeLock(struct Handler *, struct Lock *);
 884 *
 885 *   FUNCTION
 886 *
 887 *   INPUTS
 888 *       lock - May be NULL.
 889 *
 890 *   RESULT
 891 *
 892 *   EXAMPLE
 893 *
 894 *   NOTES
 895 *
 896 *   BUGS
 897 *
 898 *   SEE ALSO
 899 *
 900 ****************************************************************************
 901 *
 902 */
 903
 904 BOOL CmdFreeLock(struct Handler *handler, struct Lock *lock)
 905 {
 906    struct Object *object;
 907
 908    if(lock != NULL)
 909    {
 910       object = (APTR)((struct FileLock *)lock)->fl_Key;
 911
 912       handler->lock_count--;
 913       if((--lock->lock_count) == 0)
 914       {
 915          FreePooled(handler->public_pool, lock, sizeof(struct Lock));
 916          object->lock = NULL;
 917       }
 918    }
 919
 920    return TRUE;
 921 }
 922
 923
 924
 925 /****i* ram.handler/CmdCopyDir *********************************************
 926 *
 927 *   NAME
 928 *       CmdCopyDir --
 929 *
 930 *   SYNOPSIS
 931 *       lock = CmdCopyDir(handler, lock)
 932 *
 933 *       struct Lock *CmdCopyDir(struct Handler *, struct Lock *);
 934 *
 935 *   FUNCTION
 936 *
 937 *   INPUTS
 938 *
 939 *   RESULT
 940 *
 941 *   EXAMPLE
 942 *
 943 *   NOTES
 944 *
 945 *   BUGS
 946 *
 947 *   SEE ALSO
 948 *
 949 ****************************************************************************
 950 *
 951 */
 952
 953 struct Lock *CmdCopyDir(struct Handler *handler, struct Lock *lock)
 954 {
 955    lock = FIXLOCK(handler, lock);
 956    lock = LockObject(handler, (APTR)((struct FileLock *)lock)->fl_Key,
 957       ACCESS_READ);
 958
 959    return lock;
 960 }
 961
 962
 963
 964 /****i* ram.handler/CmdCopyDirFH *******************************************
 965 *
 966 *   NAME
 967 *       CmdCopyDirFH --
 968 *
 969 *   SYNOPSIS
 970 *       lock = CmdCopyDirFH(handler, opening)
 971 *
 972 *       struct Lock *CmdCopyDirFH(struct Handler *, struct Opening *);
 973 *
 974 *   FUNCTION
 975 *
 976 *   INPUTS
 977 *
 978 *   RESULT
 979 *
 980 *   EXAMPLE
 981 *
 982 *   NOTES
 983 *
 984 *   BUGS
 985 *
 986 *   SEE ALSO
 987 *
 988 ****************************************************************************
 989 *
 990 */
 991
 992 struct Lock *CmdCopyDirFH(struct Handler *handler,
 993    struct Opening *opening)
 994 {
 995    return LockObject(handler, opening->file, ACCESS_READ);
 996 }
 997
 998
 999
1000 /****i* ram.handler/CmdParent **********************************************
1001 *
1002 *   NAME
1003 *       CmdParent --
1004 *
1005 *   SYNOPSIS
1006 *       lock = CmdParent(handler, lock)
1007 *
1008 *       struct Lock *CmdParent(struct Handler *, struct Lock *);
1009 *
1010 *   FUNCTION
1011 *
1012 *   INPUTS
1013 *
1014 *   RESULT
1015 *
1016 *   EXAMPLE
1017 *
1018 *   NOTES
1019 *
1020 *   BUGS
1021 *
1022 *   SEE ALSO
1023 *
1024 ****************************************************************************
1025 *
1026 */
1027
1028 struct Lock *CmdParent(struct Handler *handler, struct Lock *lock)
1029 {
1030    struct Object *parent;
1031    LONG error = 0;
1032
1033    lock = FIXLOCK(handler, lock);
1034
1035    parent = ((struct Object *)((struct FileLock *)lock)->fl_Key)->parent;
1036    if(parent != NULL)
1037    {
1038       lock = LockObject(handler, parent, ACCESS_READ);
1039       if(lock == NULL)
1040          error = IoErr();
1041    }
1042    else
1043       lock = NULL;
1044
1045    SetIoErr(error);
1046    return lock;
1047 }
1048
1049
1050
1051 /****i* ram.handler/CmdParentFH ********************************************
1052 *
1053 *   NAME
1054 *       CmdParentFH --
1055 *
1056 *   SYNOPSIS
1057 *       lock = CmdParentFH(handler, opening)
1058 *
1059 *       struct Lock *CmdParentFH(struct Handler *, struct Opening *);
1060 *
1061 *   FUNCTION
1062 *
1063 *   INPUTS
1064 *
1065 *   RESULT
1066 *
1067 *   EXAMPLE
1068 *
1069 *   NOTES
1070 *
1071 *   BUGS
1072 *
1073 *   SEE ALSO
1074 *
1075 ****************************************************************************
1076 *
1077 */
1078
1079 struct Lock *CmdParentFH(struct Handler *handler,
1080    struct Opening *opening)
1081 {
1082    struct Object *parent;
1083    struct Lock *lock;
1084
1085    parent = opening->file->parent;
1086    lock = LockObject(handler, parent, ACCESS_READ);
1087
1088    return lock;
1089 }
1090
1091
1092
1093 /****i* ram.handler/CmdSameLock ********************************************
1094 *
1095 *   NAME
1096 *       CmdSameLock --
1097 *
1098 *   SYNOPSIS
1099 *       result = CmdSameLock(handler, lock1, lock2)
1100 *
1101 *       BOOL CmdSameLock(struct Handler *, struct Lock *, struct Lock *);
1102 *
1103 *   FUNCTION
1104 *
1105 *   INPUTS
1106 *
1107 *   RESULT
1108 *
1109 *   EXAMPLE
1110 *
1111 *   NOTES
1112 *
1113 *   BUGS
1114 *
1115 *   SEE ALSO
1116 *
1117 ****************************************************************************
1118 *
1119 */
1120
1121 BOOL CmdSameLock(struct Handler *handler, struct Lock *lock1, struct Lock *lock2)
1122 {
1123    SetIoErr(0);
1124    return lock1 == lock2;
1125 }
1126
1127
1128
1129 /****i* ram.handler/CmdCreateDir *******************************************
1130 *
1131 *   NAME
1132 *       CmdCreateDir --
1133 *
1134 *   SYNOPSIS
1135 *       lock = CmdCreateDir(handler, lock, name)
1136 *
1137 *       struct Lock *CmdCreateDir(struct Handler *, struct Lock *, TEXT *);
1138 *
1139 *   FUNCTION
1140 *
1141 *   INPUTS
1142 *
1143 *   RESULT
1144 *
1145 *   EXAMPLE
1146 *
1147 *   NOTES
1148 *
1149 *   BUGS
1150 *
1151 *   SEE ALSO
1152 *
1153 ****************************************************************************
1154 *
1155 */
1156
1157 struct Lock *CmdCreateDir(struct Handler *handler,
1158    struct Lock *lock, const TEXT *name)
1159 {
1160    struct Object *dir, *parent;
1161    LONG error = 0;
1162
1163    /* Find parent directory and possible name clash */
1164
1165    dir = GetHardObject(handler, lock, name, &parent);
1166    lock = NULL;
1167
1168    /* Create a new directory */
1169
1170    if(dir == NULL)
1171    {
1172       if(parent != NULL)
1173       {
1174          if(!handler->locked)
1175          {
1176             dir = CreateObject(handler, FilePart(name), ST_USERDIR, parent);
1177             if(dir != NULL)
1178             {
1179                lock = LockObject(handler, dir, ACCESS_WRITE);
1180                if(lock != NULL)
1181                {
1182                   MatchNotifyRequests(handler);
1183                   NotifyAll(handler, dir, FALSE);
1184                }
1185                else
1186                {
1187                   error = IoErr();
1188                   DeleteObject(handler, dir);
1189                }
1190             }
1191             else
1192                error = IoErr();
1193          }
1194          else
1195             error = ERROR_DISK_WRITE_PROTECTED;
1196       }
1197       else
1198          error = IoErr();
1199    }
1200    else
1201       error = ERROR_OBJECT_EXISTS;
1202
1203    /* Set error code and return lock on new directory */
1204
1205    SetIoErr(error);
1206    return lock;
1207 }
1208
1209
1210
1211 /****i* ram.handler/CmdExamineObject ***************************************
1212 *
1213 *   NAME
1214 *       CmdExamineObject --
1215 *
1216 *   SYNOPSIS
1217 *       success = CmdExamineObject(handler, lock,
1218 *           info)
1219 *
1220 *       BOOL CmdExamineObject(struct Handler *, struct Lock *,
1221 *           struct FileInfoBlock *);
1222 *
1223 *   FUNCTION
1224 *
1225 *   INPUTS
1226 *
1227 *   RESULT
1228 *
1229 *   EXAMPLE
1230 *
1231 *   NOTES
1232 *
1233 *   BUGS
1234 *
1235 *   SEE ALSO
1236 *
1237 ****************************************************************************
1238 *
1239 */
1240
1241 BOOL CmdExamineObject(struct Handler *handler, struct Lock *lock,
1242    struct FileInfoBlock *info)
1243 {
1244    lock = FIXLOCK(handler, lock);
1245    return ExamineObject(handler, (APTR)((struct FileLock *)lock)->fl_Key,
1246       info);
1247 }
1248
1249
1250
1251 /****i* ram.handler/CmdExamineFH *******************************************
1252 *
1253 *   NAME
1254 *       CmdExamineFH --
1255 *
1256 *   SYNOPSIS
1257 *       success = CmdExamineFH(handler, opening,
1258 *           info)
1259 *
1260 *       BOOL CmdExamineFH(struct Handler *, struct Opening *,
1261 *           struct FileInfoBlock *);
1262 *
1263 *   FUNCTION
1264 *
1265 *   INPUTS
1266 *
1267 *   RESULT
1268 *
1269 *   EXAMPLE
1270 *
1271 *   NOTES
1272 *
1273 *   BUGS
1274 *
1275 *   SEE ALSO
1276 *
1277 ****************************************************************************
1278 *
1279 */
1280
1281 BOOL CmdExamineFH(struct Handler *handler, struct Opening *opening,
1282    struct FileInfoBlock *info)
1283 {
1284    return ExamineObject(handler, opening->file, info);
1285 }
1286
1287
1288
1289 /****i* ram.handler/CmdExamineNext *****************************************
1290 *
1291 *   NAME
1292 *       CmdExamineNext --
1293 *
1294 *   SYNOPSIS
1295 *       success = CmdExamineNext(handler, info)
1296 *
1297 *       BOOL CmdExamineNext(struct Handler *, struct FileInfoBlock *);
1298 *
1299 *   FUNCTION
1300 *
1301 *   INPUTS
1302 *
1303 *   RESULT
1304 *
1305 *   EXAMPLE
1306 *
1307 *   NOTES
1308 *
1309 *   BUGS
1310 *
1311 *   SEE ALSO
1312 *
1313 ****************************************************************************
1314 *
1315 */
1316
1317 BOOL CmdExamineNext(struct Handler *handler, struct FileInfoBlock *info)
1318 {
1319    return ExamineObject(handler, NULL, info);
1320 }
1321
1322
1323
1324 /****i* ram.handler/CmdExamineAll ******************************************
1325 *
1326 *   NAME
1327 *       CmdExamineAll --
1328 *
1329 *   SYNOPSIS
1330 *       success = CmdExamineAll(handler, opening, buffer, size,
1331 *           type, control)
1332 *
1333 *       BOOL CmdExamineAll(struct Handler *, struct Lock *, UBYTE *, ULONG,
1334 *           ULONG, struct ExAllControl *);
1335 *
1336 *   FUNCTION
1337 *
1338 *   INPUTS
1339 *
1340 *   RESULT
1341 *
1342 *   EXAMPLE
1343 *
1344 *   NOTES
1345 *
1346 *   BUGS
1347 *
1348 *   SEE ALSO
1349 *
1350 ****************************************************************************
1351 *
1352 * Note: we work under the assumption that if an error occurs, the caller
1353 * will have to start from scratch if they want the rest of the entries.
1354 *
1355 */
1356
1357 BOOL CmdExamineAll(struct Handler *handler, struct Lock *lock,
1358    UBYTE *buffer, ULONG size, ULONG type, struct ExAllControl *control)
1359 {
1360    BOOL match;
1361    ULONG entry_count = 0;
1362    struct Object *object, *next_object, *real_object;
1363    TEXT *name, *comment, *pattern, *name_copy, *comment_copy;
1364    LONG error = 0;
1365    struct ExAllData *entry, *prev_entry = NULL;
1366    struct Hook *match_hook;
1367    UWORD struct_size, name_size, comment_size, entry_size;
1368    struct Examination *examination;
1369
1370    /* Check we support the requested format */
1371
1372    if(type > ED_COMMENT)
1373       error = ERROR_BAD_NUMBER;
1374
1375    /* Get starting point */
1376
1377    examination = (APTR)control->eac_LastKey;
1378
1379    if(examination != NULL)
1380    {
1381       object = examination->next_object;
1382    }
1383    else
1384    {
1385       object = (APTR)((struct FileLock *)lock)->fl_Key;
1386       object = (APTR)object->elements.mlh_Head;
1387    }
1388
1389    while(error == 0)
1390    {
1391       next_object = (struct Object *)((struct Node *)object)->ln_Succ;
1392
1393       if(next_object != NULL)
1394       {
1395          struct_size = examine_sizes[type - 1];
1396          name = ((struct Node *)object)->ln_Name;
1397          name_size = StrSize(name);
1398          if(((struct Node *)object)->ln_Pri == ST_SOFTLINK)
1399             comment = &((struct Node *)object)->ln_Type;
1400          else
1401             comment = object->comment;
1402          comment_size = StrSize(comment);
1403          entry_size = struct_size + name_size;
1404          if(type >= ED_COMMENT)
1405             entry_size += comment_size;
1406          entry_size = (entry_size + 1) & (~0x1);
1407
1408          pattern = control->eac_MatchString;
1409          if(pattern != NULL)
1410             match = MatchPatternNoCase(pattern, name);
1411          else
1412             match = TRUE;
1413
1414          if(match && entry_size <= size)
1415          {
1416             /* Fill in entry */
1417
1418             entry = (APTR)buffer;
1419             entry->ed_Next = NULL;
1420
1421             real_object = GetRealObject(object);
1422             name_copy = buffer + struct_size;
1423             CopyMem(name, name_copy, name_size);
1424             entry->ed_Name = name_copy;
1425
1426             if(type >= ED_TYPE)
1427                entry->ed_Type = ((struct Node *)object)->ln_Pri;
1428
1429             if(type >= ED_SIZE)
1430                entry->ed_Size = real_object->length;
1431
1432             if(type >= ED_PROTECTION)
1433                entry->ed_Prot = real_object->protection;
1434
1435             if(type >= ED_DATE)
1436             {
1437                entry->ed_Days = real_object->date.ds_Days;
1438                entry->ed_Mins = real_object->date.ds_Minute;
1439                entry->ed_Ticks = real_object->date.ds_Tick;
1440             }
1441
1442             if(type >= ED_COMMENT)
1443             {
1444                comment_copy = buffer + struct_size + name_size;
1445                CopyMem(comment, comment_copy, comment_size);
1446                entry->ed_Comment = comment_copy;
1447             }
1448
1449             /* Call the filter hook if present */
1450
1451             match_hook = control->eac_MatchFunc;
1452             if(match_hook != NULL)
1453                match = CallHookPkt(match_hook, &type, entry);
1454             else
1455                match = TRUE;
1456
1457             /* Prepare for next entry if current one accepted */
1458
1459             if(match)
1460             {
1461                buffer += entry_size;
1462                size -= entry_size;
1463                entry_count++;
1464                if(prev_entry != NULL)
1465                   prev_entry->ed_Next = entry;
1466                prev_entry = entry;
1467             }
1468          }
1469          else if(match)
1470             error = ERROR_NO_FREE_STORE;
1471       }
1472       else
1473          error = ERROR_NO_MORE_ENTRIES;
1474
1475       object = next_object;
1476    }
1477
1478    /* Running out of space isn't an error unless no entries could fit */
1479
1480    if(error == ERROR_NO_FREE_STORE && entry_count != 0)
1481       error = 0;
1482
1483    /* Prepare for subsequent call */
1484
1485    if(error == 0 && examination == NULL)
1486    {
1487       examination = AllocPooled(handler->clear_pool,
1488          sizeof(struct Examination));
1489       if(examination != NULL)
1490          AddTail((APTR)&handler->examinations, (APTR)examination);
1491       else
1492          error = IoErr();
1493    }
1494
1495    if(error == 0)
1496    {
1497       examination->next_object = object;
1498       control->eac_LastKey = (UPINT)examination;
1499    }
1500    else
1501    {
1502       CmdExamineAllEnd(handler, lock, buffer, size, type, control);
1503    }
1504
1505    control->eac_Entries = entry_count;
1506
1507    /* Return */
1508
1509    SetIoErr(error);
1510    return error == 0;
1511 }
1512
1513
1514
1515 /****i* ram.handler/CmdExamineAllEnd ***************************************
1516 *
1517 *   NAME
1518 *       CmdExamineAllEnd --
1519 *
1520 *   SYNOPSIS
1521 *       CmdExamineAllEnd(handler, opening, buffer,
1522 *           size, type, control)
1523 *
1524 *       VOID CmdExamineAllEnd(struct Handler *, struct Lock *, UBYTE *,
1525 *           ULONG, ULONG, struct ExAllControl *);
1526 *
1527 *   FUNCTION
1528 *
1529 *   INPUTS
1530 *
1531 *   RESULT
1532 *
1533 *   EXAMPLE
1534 *
1535 *   NOTES
1536 *
1537 *   BUGS
1538 *
1539 *   SEE ALSO
1540 *
1541 ****************************************************************************
1542 *
1543 */
1544
1545 VOID CmdExamineAllEnd(struct Handler *handler, struct Lock *lock,
1546    UBYTE *buffer, ULONG size, ULONG type, struct ExAllControl *control)
1547 {
1548    struct Examination *examination;
1549
1550    examination = (APTR)control->eac_LastKey;
1551    if(examination != NULL)
1552    {
1553       Remove((APTR)examination);
1554       FreePooled(handler->clear_pool, examination,
1555          sizeof(struct Examination));
1556    }
1557
1558    return;
1559 }
1560
1561
1562
1563 /****i* ram.handler/CmdInfo ************************************************
1564 *
1565 *   NAME
1566 *       CmdInfo --
1567 *
1568 *   SYNOPSIS
1569 *       success = CmdInfo(handler, info_data)
1570 *
1571 *       BOOL CmdExamineObject(struct Handler *, struct InfoData *);
1572 *
1573 *   FUNCTION
1574 *
1575 *   INPUTS
1576 *
1577 *   RESULT
1578 *
1579 *   EXAMPLE
1580 *
1581 *   NOTES
1582 *
1583 *   BUGS
1584 *
1585 *   SEE ALSO
1586 *
1587 ****************************************************************************
1588 *
1589 */
1590
1591 BOOL CmdInfo(struct Handler *handler, struct InfoData *info_data)
1592 {
1593    LONG disk_state;
1594
1595    info_data->id_NumSoftErrors = 0;
1596    info_data->id_UnitNumber = 0;
1597    if(handler->locked)
1598       disk_state = ID_WRITE_PROTECTED;
1599    else
1600       disk_state = ID_VALIDATED;
1601    info_data->id_DiskState = disk_state;
1602    info_data->id_NumBlocks = handler->block_count
1603       + MEMBLOCKS(AvailMem(MEMF_ANY));
1604    info_data->id_NumBlocksUsed = handler->block_count;
1605    info_data->id_BytesPerBlock = MEM_BLOCKSIZE;
1606    info_data->id_DiskType = ID_DOS_DISK;
1607    info_data->id_VolumeNode = MKBADDR(handler->volume);
1608    info_data->id_InUse = DOSBOOL(handler->lock_count > 1);
1609
1610    return TRUE;
1611 }
1612
1613
1614
1615 /****i* ram.handler/CmdSetProtect ******************************************
1616 *
1617 *   NAME
1618 *       CmdSetProtect --
1619 *
1620 *   SYNOPSIS
1621 *       success = CmdSetProtect(handler, lock, name, flags)
1622 *
1623 *       BOOL CmdSetProtect(struct Handler *, struct Lock *, TEXT *, ULONG);
1624 *
1625 *   FUNCTION
1626 *
1627 *   INPUTS
1628 *
1629 *   RESULT
1630 *
1631 *   EXAMPLE
1632 *
1633 *   NOTES
1634 *
1635 *   BUGS
1636 *
1637 *   SEE ALSO
1638 *
1639 ****************************************************************************
1640 *
1641 */
1642
1643 BOOL CmdSetProtect(struct Handler *handler, struct Lock *lock,
1644    const TEXT *name, ULONG flags)
1645 {
1646    LONG error = 0;
1647    struct Object *object;
1648
1649    /* Set new protection flags if object isn't in use */
1650
1651    object = GetHardObject(handler, lock, name, NULL);
1652    if(object != NULL)
1653    {
1654       if(handler->locked)
1655          error = ERROR_DISK_WRITE_PROTECTED;
1656
1657       if(error == 0)
1658       {
1659          object = GetRealObject(object);
1660          object->protection = flags;
1661          NotifyAll(handler, object, TRUE);
1662       }
1663    }
1664    else
1665       error = IoErr();
1666
1667    /* Return result */
1668
1669    SetIoErr(error);
1670    return error == 0;
1671 }
1672
1673
1674
1675 /****i* ram.handler/CmdSetComment ******************************************
1676 *
1677 *   NAME
1678 *       CmdSetComment --
1679 *
1680 *   SYNOPSIS
1681 *       success = CmdSetComment(handler, lock, name, comment)
1682 *
1683 *       BOOL CmdSetComment(struct Handler *, struct Lock *, TEXT *, TEXT *);
1684 *
1685 *   FUNCTION
1686 *
1687 *   INPUTS
1688 *
1689 *   RESULT
1690 *
1691 *   EXAMPLE
1692 *
1693 *   NOTES
1694 *
1695 *   BUGS
1696 *
1697 *   SEE ALSO
1698 *
1699 ****************************************************************************
1700 *
1701 */
1702
1703 BOOL CmdSetComment(struct Handler *handler, struct Lock *lock,
1704    const TEXT *name, const TEXT *comment)
1705 {
1706    LONG error = 0;
1707    struct Object *object;
1708    const TEXT *p;
1709    TEXT ch;
1710    struct Locale *locale;
1711    PINT block_diff;
1712
1713    /* Get object */
1714
1715    object = GetHardObject(handler, lock, name, NULL);
1716    if(object == NULL)
1717       error = IoErr();
1718
1719    /* Check comment isn't too long */
1720
1721    if(StrSize(comment)
1722       > sizeof(((struct FileInfoBlock *)NULL)->fib_Comment))
1723       error = ERROR_COMMENT_TOO_BIG;
1724
1725    /* Check comment doesn't have any strange characters in it */
1726    if ((locale = handler->locale)) {
1727        for(p = comment; (ch = *p) != '\0'; p++)
1728            if((ch & 0x80) == 0 && (!IsPrint(locale, ch) || IsCntrl(locale, ch)))
1729                error = ERROR_INVALID_COMPONENT_NAME;
1730    }
1731
1732    /* Check volume isn't write-protected */
1733
1734    if(handler->locked)
1735       error = ERROR_DISK_WRITE_PROTECTED;
1736
1737    /* Store new comment */
1738
1739    if(error == 0)
1740    {
1741       block_diff = SetString(handler, &object->comment, comment);
1742       if(block_diff == -1)
1743          error = IoErr();
1744       else
1745       {
1746          object->block_count += block_diff;
1747          handler->block_count += block_diff;
1748       }
1749    }
1750
1751    /* Notify interested parties */
1752
1753    if(error == 0)
1754    {
1755       NotifyAll(handler, object, FALSE);
1756    }
1757
1758    /* Return result */
1759
1760    SetIoErr(error);
1761    return error == 0;
1762 }
1763
1764
1765
1766 /****i* ram.handler/CmdRenameObject ****************************************
1767 *
1768 *   NAME
1769 *       CmdRenameObject --
1770 *
1771 *   SYNOPSIS
1772 *       success = CmdRenameObject(handler, old_lock, old_name,
1773 *           new_lock, new_name)
1774 *
1775 *       BOOL CmdRenameObject(struct Handler *, struct Lock *, STRPTR,
1776 *           struct Lock *, STRPTR);
1777 *
1778 *   FUNCTION
1779 *
1780 *   INPUTS
1781 *
1782 *   RESULT
1783 *
1784 *   EXAMPLE
1785 *
1786 *   NOTES
1787 *
1788 *   BUGS
1789 *
1790 *   SEE ALSO
1791 *
1792 ****************************************************************************
1793 *
1794 */
1795
1796 BOOL CmdRenameObject(struct Handler *handler, struct Lock *old_lock,
1797    STRPTR old_name, struct Lock *new_lock, STRPTR new_name)
1798 {
1799    struct Object *parent, *object, *duplicate, *p;
1800    LONG error = 0;
1801
1802    /* Get object to be moved */
1803
1804    object = GetHardObject(handler, old_lock, old_name, NULL);
1805    if(object == NULL)
1806       error = IoErr();
1807
1808    /* Get destination directory and check if a different object already has
1809       the target name */
1810
1811    duplicate = GetHardObject(handler, new_lock, new_name, &parent);
1812    if(duplicate != NULL && duplicate != object)
1813       error = ERROR_OBJECT_EXISTS;
1814    if(parent == NULL)
1815       error = IoErr();
1816
1817    /* Check for a circular rename */
1818
1819    for(p = parent; p != NULL; p = p->parent)
1820    {
1821       if(p == object)
1822          error = ERROR_OBJECT_NOT_FOUND;
1823    }
1824
1825    /* Check volume isn't write-protected */
1826
1827    if(handler->locked)
1828       error = ERROR_DISK_WRITE_PROTECTED;
1829
1830    /* Give the object its new name */
1831
1832    if(error == 0)
1833    {
1834       if(!SetName(handler, object, FilePart(new_name)))
1835          error = IoErr();
1836    }
1837
1838    if(error == 0)
1839    {
1840       if(object->parent != parent)
1841       {
1842          /* Remove object from old parent and place it in new parent */
1843
1844          Remove((struct Node *)object);
1845          AddTail((struct List *)&parent->elements, (struct Node *)object);
1846          object->parent = parent;
1847          AdjustExaminations(handler, object);
1848       }
1849
1850       if(object != duplicate)
1851       {
1852          /* Update notifications */
1853
1854          NotifyAll(handler, object, FALSE);
1855          UnmatchNotifyRequests(handler, object);
1856          MatchNotifyRequests(handler);
1857       }
1858
1859       NotifyAll(handler, object, FALSE);
1860    }
1861
1862    /* Return success indicator */
1863
1864    SetIoErr(error);
1865    return error == 0;
1866 }
1867
1868
1869
1870 /****i* ram.handler/CmdRenameDisk ******************************************
1871 *
1872 *   NAME
1873 *       CmdRenameDisk --
1874 *
1875 *   SYNOPSIS
1876 *       success = CmdRenameDisk(handler, new_name)
1877 *
1878 *       BOOL CmdRenameDisk(struct Handler *, STRPTR);
1879 *
1880 *   FUNCTION
1881 *
1882 *   INPUTS
1883 *
1884 *   RESULT
1885 *
1886 *   EXAMPLE
1887 *
1888 *   NOTES
1889 *
1890 *   BUGS
1891 *
1892 *   SEE ALSO
1893 *
1894 ****************************************************************************
1895 *
1896 */
1897
1898 BOOL CmdRenameDisk(struct Handler *handler, STRPTR new_name)
1899 {
1900    LONG error = 0;
1901
1902    /* Check volume isn't write-protected */
1903
1904    if(handler->locked)
1905       error = ERROR_DISK_WRITE_PROTECTED;
1906
1907    /* Rename volume's DOS entry and root directory */
1908
1909    if(error == 0)
1910       if(!SetName(handler, handler->root_dir, new_name))
1911          error = IoErr();
1912
1913    if(error == 0)
1914       if(!MyRenameDosEntry(handler, handler->volume, new_name))
1915          error = IoErr();
1916
1917    /* Return success indicator */
1918
1919    SetIoErr(error);
1920    return error == 0;
1921 }
1922
1923
1924
1925 /****i* ram.handler/CmdSetDate *********************************************
1926 *
1927 *   NAME
1928 *       CmdSetDate --
1929 *
1930 *   SYNOPSIS
1931 *       success = CmdSetDate(handler, lock, name,
1932 *           date)
1933 *
1934 *       BOOL CmdSetDate(struct Handler *, struct Lock *, STRPTR,
1935 *           struct DateStamp *);
1936 *
1937 *   FUNCTION
1938 *
1939 *   INPUTS
1940 *
1941 *   RESULT
1942 *
1943 *   EXAMPLE
1944 *
1945 *   NOTES
1946 *
1947 *   BUGS
1948 *
1949 *   SEE ALSO
1950 *
1951 ****************************************************************************
1952 *
1953 */
1954
1955 BOOL CmdSetDate(struct Handler *handler, struct Lock *lock, STRPTR name,
1956    struct DateStamp *date)
1957 {
1958    struct Object *object;
1959    LONG error = 0;
1960
1961    /* Check volume isn't write-protected */
1962
1963    if(handler->locked)
1964       error = ERROR_DISK_WRITE_PROTECTED;
1965
1966    /* Get object and set its new date */
1967
1968    if(error == 0)
1969    {
1970       object = GetHardObject(handler, lock, name, NULL);
1971       if(object != NULL)
1972       {
1973          object = GetRealObject(object);
1974          CopyMem(date, &object->date, sizeof(struct DateStamp));
1975       }
1976       else
1977          error = IoErr();
1978    }
1979
1980    /* Notify interested parties */
1981
1982    if(error == 0)
1983    {
1984       NotifyAll(handler, object, TRUE);
1985    }
1986
1987    /* Return result */
1988
1989    SetIoErr(error);
1990    return error == 0;
1991 }
1992
1993
1994
1995 /****i* ram.handler/CmdDeleteObject ****************************************
1996 *
1997 *   NAME
1998 *       CmdDeleteObject --
1999 *
2000 *   SYNOPSIS
2001 *       success = CmdDeleteObject(handler, lock, name)
2002 *
2003 *       BOOL CmdDeleteObject(struct Handler *, struct Lock *, STRPTR);
2004 *
2005 *   FUNCTION
2006 *
2007 *   INPUTS
2008 *
2009 *   RESULT
2010 *
2011 *   EXAMPLE
2012 *
2013 *   NOTES
2014 *
2015 *   BUGS
2016 *
2017 *   SEE ALSO
2018 *
2019 ****************************************************************************
2020 *
2021 */
2022
2023 BOOL CmdDeleteObject(struct Handler *handler, struct Lock *lock,
2024    STRPTR name)
2025 {
2026    LONG error = 0, pos = -1;
2027    struct Object *object;
2028
2029    /* Find object and check it can be deleted */
2030
2031    object = GetObject(handler, lock, name, NULL, &pos);
2032    if(object == NULL || pos != -1)
2033       error = IoErr();
2034
2035    if(handler->locked)
2036       error = ERROR_DISK_WRITE_PROTECTED;
2037
2038    if(error == 0)
2039    {
2040       if((GetRealObject(object)->protection & FIBF_DELETE) != 0)
2041          error = ERROR_DELETE_PROTECTED;
2042    }
2043
2044    /* Attempt to delete object */
2045
2046    if(error == 0)
2047    {
2048       if(!AttemptDeleteObject(handler, object, TRUE))
2049          error = IoErr();
2050    }
2051
2052    /* Return result */
2053
2054    SetIoErr(error);
2055    return error == 0;
2056 }
2057
2058
2059
2060 /****i* ram.handler/CmdCurrentVolume ***************************************
2061 *
2062 *   NAME
2063 *       CmdCurrentVolume --
2064 *
2065 *   SYNOPSIS
2066 *       volume = CmdCurrentVolume(handler)
2067 *
2068 *       struct DosList *CmdCurrentVolume(struct Handler *);
2069 *
2070 *   FUNCTION
2071 *
2072 *   INPUTS
2073 *
2074 *   RESULT
2075 *
2076 *   EXAMPLE
2077 *
2078 *   NOTES
2079 *
2080 *   BUGS
2081 *
2082 *   SEE ALSO
2083 *
2084 ****************************************************************************
2085 *
2086 */
2087
2088 struct DosList *CmdCurrentVolume(struct Handler *handler)
2089 {
2090    SetIoErr(0);
2091    return handler->volume;
2092 }
2093
2094
2095
2096 /****i* ram.handler/CmdChangeMode ******************************************
2097 *
2098 *   NAME
2099 *       CmdChangeMode --
2100 *
2101 *   SYNOPSIS
2102 *       success = CmdChangeMode(handler, type, thing, new_mode)
2103 *
2104 *       BOOL CmdChangeMode(struct Handler *, ULONG, APTR, ULONG);
2105 *
2106 *   FUNCTION
2107 *
2108 *   INPUTS
2109 *
2110 *   RESULT
2111 *
2112 *   EXAMPLE
2113 *
2114 *   NOTES
2115 *
2116 *   BUGS
2117 *
2118 *   SEE ALSO
2119 *
2120 ****************************************************************************
2121 *
2122 */
2123
2124 BOOL CmdChangeMode(struct Handler *handler, ULONG type, APTR thing, ULONG new_mode)
2125 {
2126    struct Lock *lock;
2127    struct Opening *opening;
2128    LONG error = 0;
2129
2130    /* Get the lock */
2131
2132    if(type == CHANGE_FH)
2133    {
2134       opening = (APTR)((struct FileHandle *)thing)->fh_Arg1;
2135       lock = opening->file->lock;
2136    }
2137    else
2138       lock = thing;
2139
2140    /* Change mode if possible */
2141
2142    if(new_mode == ACCESS_WRITE && lock->lock_count > 1)
2143    {
2144       error = ERROR_OBJECT_IN_USE;
2145    }
2146    else
2147    {
2148       ((struct FileLock *)lock)->fl_Access = new_mode;
2149    }
2150
2151    /* Set error code and return result */
2152
2153    SetIoErr(error);
2154    return error == 0;
2155 }
2156
2157
2158
2159 /****i* ram.handler/CmdMakeLink ********************************************
2160 *
2161 *   NAME
2162 *       CmdMakeLink --
2163 *
2164 *   SYNOPSIS
2165 *       success = CmdMakeLink(handler, lock, name, reference,
2166 *           link_type)
2167 *
2168 *       BOOL CmdMakeLink(struct Handler *, struct Lock *, STRPTR, APTR,
2169 *           LONG);
2170 *
2171 *   FUNCTION
2172 *
2173 *   INPUTS
2174 *
2175 *   RESULT
2176 *
2177 *   EXAMPLE
2178 *
2179 *   NOTES
2180 *
2181 *   BUGS
2182 *
2183 *   SEE ALSO
2184 *
2185 ****************************************************************************
2186 *
2187 */
2188
2189 BOOL CmdMakeLink(struct Handler *handler, struct Lock *lock, STRPTR name,
2190    APTR reference, LONG link_type)
2191 {
2192    struct Object *link, *parent, *target = NULL, *master_link;
2193    LONG error = 0, object_type;
2194    PINT block_diff;
2195    struct MinNode *node;
2196
2197    /* Find parent directory and possible name clash */
2198
2199    link = GetHardObject(handler, lock, name, &parent);
2200    if(link != NULL)
2201       error = ERROR_OBJECT_EXISTS;
2202    else if(parent == NULL)
2203       error = IoErr();
2204
2205    /* Determine link type */
2206
2207    if(link_type == LINK_HARD)
2208    {
2209       target = (APTR)((struct FileLock *)reference)->fl_Key;
2210       if(((struct Node *)target)->ln_Pri == ST_FILE)
2211          object_type = ST_LINKFILE;
2212       else
2213          object_type = ST_LINKDIR;
2214    }
2215    else
2216       object_type = ST_SOFTLINK;
2217
2218    /* Check volume isn't write-protected */
2219
2220    if(error == 0)
2221    {
2222       if(handler->locked)
2223          error = ERROR_DISK_WRITE_PROTECTED;
2224    }
2225
2226    /* Create a new link */
2227
2228    if(error == 0)
2229    {
2230       link = CreateObject(handler, FilePart(name), object_type, parent);
2231       if(link == NULL)
2232          error = IoErr();
2233    }
2234
2235    /* Store link target */
2236
2237    if(error == 0)
2238    {
2239       if(link_type == LINK_HARD)
2240       {
2241          node = target->hard_link.mln_Succ;
2242          if(node == NULL)
2243          {
2244             master_link = link;
2245             AddTail((APTR)&master_link->elements, (APTR)&target->hard_link);
2246          }
2247          else
2248             master_link = HARDLINK(node);
2249          AddTail((APTR)&master_link->elements, (APTR)&link->hard_link);
2250       }
2251       else
2252       {
2253          block_diff =
2254             SetString(handler, (APTR)&link->soft_link_target, reference);
2255          if(block_diff == -1)
2256             error = IoErr();
2257          else
2258          {
2259             link->block_count += block_diff;
2260             handler->block_count += block_diff;
2261          }
2262       }
2263    }
2264
2265    /* Notify */
2266
2267    if(error == 0)
2268       NotifyAll(handler, link, FALSE);
2269
2270    /* Return success indicator */
2271
2272    SetIoErr(error);
2273    return error == 0;
2274 }
2275
2276
2277
2278 /****i* ram.handler/CmdReadLink ********************************************
2279 *
2280 *   NAME
2281 *       CmdReadLink --
2282 *
2283 *   SYNOPSIS
2284 *       success = CmdReadLink(handler, lock, name, buffer,
2285 *           buffer_size)
2286 *
2287 *       BOOL CmdReadLink(struct Handler *, struct Lock *, const TEXT *,
2288 *           TEXT *, LONG);
2289 *
2290 *   FUNCTION
2291 *
2292 *   INPUTS
2293 *
2294 *   RESULT
2295 *
2296 *   EXAMPLE
2297 *
2298 *   NOTES
2299 *
2300 *   BUGS
2301 *
2302 *   SEE ALSO
2303 *
2304 ****************************************************************************
2305 *
2306 */
2307
2308 LONG CmdReadLink(struct Handler *handler, struct Lock *lock,
2309    const TEXT *name, TEXT *buffer, LONG buffer_size)
2310 {
2311    struct Object *link;
2312    LONG error = 0, pos, length;
2313    const TEXT *p;
2314
2315    /* Get link object */
2316
2317    link = GetObject(handler, lock, name, NULL, &pos);
2318    if(link == NULL)
2319       error = IoErr();
2320    else if(((struct Node *)link)->ln_Pri != ST_SOFTLINK)
2321       error = ERROR_OBJECT_WRONG_TYPE;
2322
2323    if(error == 0)
2324    {
2325       /* Copy part of path preceding link to buffer so that returned path
2326          will be relative to lock passed in */
2327
2328       if(pos == -1)
2329          p = name + StrLen(name) - 1;
2330       else
2331          p = name + pos - 2;
2332
2333       while(p != name && *p != '/' && *p != ':')
2334          p--;
2335
2336       length = p - name;
2337       if(*p == '/' || *p == ':')
2338          length++;
2339       if(buffer_size >= length + 1)
2340       {
2341          CopyMem(name, buffer, length);
2342          buffer[length] = '\0';
2343       }
2344       else
2345          error = ERROR_BUFFER_OVERFLOW;
2346    }
2347
2348    if(error == 0)
2349    {
2350       /* Add link target to link's parent path */
2351
2352       if(AddPart(buffer, link->soft_link_target, buffer_size))
2353       {
2354          /* Add remainder of original path after link */
2355
2356          if(pos != -1)
2357          {
2358             if(!AddPart(buffer, name + pos, buffer_size))
2359                error = ERROR_LINE_TOO_LONG;
2360          }
2361       }
2362       else
2363          error = ERROR_BUFFER_OVERFLOW;
2364    }
2365
2366    /* Return path length or error indicator */
2367
2368    if(error == ERROR_BUFFER_OVERFLOW)
2369       length = -2;
2370    else if(error != 0)
2371       length = -1;
2372    else
2373       length = StrLen(buffer);
2374
2375    SetIoErr(error);
2376    return length;
2377 }
2378
2379
2380
2381 /****i* ram.handler/CmdWriteProtect ****************************************
2382 *
2383 *   NAME
2384 *       CmdWriteProtect --
2385 *
2386 *   SYNOPSIS
2387 *       success = CmdWriteProtect(handler, on, key)
2388 *
2389 *       BOOL CmdWriteProtect(struct Handler *, BOOL, ULONG);
2390 *
2391 *   FUNCTION
2392 *
2393 *   INPUTS
2394 *
2395 *   RESULT
2396 *
2397 *   EXAMPLE
2398 *
2399 *   NOTES
2400 *
2401 *   BUGS
2402 *
2403 *   SEE ALSO
2404 *
2405 ****************************************************************************
2406 *
2407 */
2408
2409 BOOL CmdWriteProtect(struct Handler *handler, BOOL on, ULONG key)
2410 {
2411    LONG error = 0;
2412    struct Object *root_dir;
2413
2414    root_dir = handler->root_dir;
2415
2416    if(on)
2417    {
2418       if(!handler->locked)
2419          root_dir->length = key;
2420       else
2421          error = ERROR_DISK_WRITE_PROTECTED;
2422    }
2423    else
2424    {
2425       if(root_dir->length != 0 && root_dir->length != key)
2426          error = ERROR_INVALID_COMPONENT_NAME;
2427       else
2428          root_dir->length = 0;
2429    }
2430
2431    if(error == 0)
2432       handler->locked = on;
2433
2434    /* Return success indicator */
2435
2436    SetIoErr(error);
2437    return error == 0;
2438 }
2439
2440
2441
2442 /****i* ram.handler/CmdFlush ***********************************************
2443 *
2444 *   NAME
2445 *       CmdFlush --
2446 *
2447 *   SYNOPSIS
2448 *       success = CmdFlush()
2449 *
2450 *       BOOL CmdFlush();
2451 *
2452 *   FUNCTION
2453 *
2454 *   INPUTS
2455 *
2456 *   RESULT
2457 *
2458 *   EXAMPLE
2459 *
2460 *   NOTES
2461 *
2462 *   BUGS
2463 *
2464 *   SEE ALSO
2465 *
2466 ****************************************************************************
2467 *
2468 */
2469
2470 BOOL CmdFlush()
2471 {
2472    return TRUE;
2473 }
2474
2475
2476
2477 /****i* ram.handler/CmdAddNotify *******************************************
2478 *
2479 *   NAME
2480 *       CmdAddNotify --
2481 *
2482 *   SYNOPSIS
2483 *       success = CmdAddNotify(handler, request)
2484 *
2485 *       BOOL CmdAddNotify(struct Handler *, struct NotifyRequest *);
2486 *
2487 *   FUNCTION
2488 *
2489 *   INPUTS
2490 *
2491 *   RESULT
2492 *
2493 *   EXAMPLE
2494 *
2495 *   NOTES
2496 *
2497 *   BUGS
2498 *
2499 *   SEE ALSO
2500 *
2501 ****************************************************************************
2502 *
2503 */
2504
2505 BOOL CmdAddNotify(struct Handler *handler, struct NotifyRequest *request)
2506 {
2507    LONG error = 0;
2508    struct Notification *notification;
2509    struct Object *object;
2510
2511    notification = AllocPooled(handler->clear_pool,
2512       sizeof(struct Notification));
2513    if(notification == NULL)
2514       error = IoErr();
2515
2516    if(error == 0)
2517    {
2518       notification->request = request;
2519       request->nr_Flags &= ~NRF_MAGIC;
2520
2521       object = GetHardObject(handler, NULL, request->nr_FullName, NULL);
2522
2523       if(object != NULL)
2524       {
2525          AddTail((APTR)&object->notifications, (APTR)notification);
2526          if((request->nr_Flags & NRF_NOTIFY_INITIAL) != 0)
2527             Notify(handler, notification);
2528       }
2529       else
2530          AddTail((APTR)&handler->notifications, (APTR)notification);
2531    }
2532
2533    /* Return success indicator */
2534
2535    SetIoErr(error);
2536    return error == 0;
2537 }
2538
2539
2540
2541 /****i* ram.handler/CmdRemoveNotify ****************************************
2542 *
2543 *   NAME
2544 *       CmdRemoveNotify --
2545 *
2546 *   SYNOPSIS
2547 *       success = CmdRemoveNotify(handler, request)
2548 *
2549 *       BOOL CmdRemoveNotify(struct Handler *, struct NotifyRequest *);
2550 *
2551 *   FUNCTION
2552 *
2553 *   INPUTS
2554 *
2555 *   RESULT
2556 *
2557 *   EXAMPLE
2558 *
2559 *   NOTES
2560 *
2561 *   BUGS
2562 *
2563 *   SEE ALSO
2564 *
2565 ****************************************************************************
2566 *
2567 */
2568
2569 BOOL CmdRemoveNotify(struct Handler *handler, struct NotifyRequest *request)
2570 {
2571    struct Notification *notification;
2572
2573    notification = FindNotification(handler, request);
2574    Remove((APTR)notification);
2575    FreePooled(handler->clear_pool, notification,
2576       sizeof(struct Notification));
2577
2578    return TRUE;
2579 }
2580
2581
2582