ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/extfs.cpp
(Generate patch)

Comparing BasiliskII/src/extfs.cpp (file contents):
Revision 1.2 by cebix, 1999-10-19T21:33:56Z vs.
Revision 1.25 by cebix, 2001-03-31T14:31:58Z

# Line 1 | Line 1
1   /*
2 < *  extfs.cpp - MacOS file system for access native file system access
2 > *  extfs.cpp - MacOS file system for native file system access
3   *
4 < *  Basilisk II (C) 1997-1999 Christian Bauer
4 > *  Basilisk II (C) 1997-2001 Christian Bauer
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 19 | Line 19
19   */
20  
21   /*
22 < TODO:
23 < LockRng
24 < UnlockRng
25 < (CatSearch)
26 < (MakeFSSpec)
27 < (GetVolMountInfoSize)
28 < (GetVolMountInfo)
29 < (GetForeignPrivs)
30 < (SetForeignPrivs)
31 < */
22 > *  SEE ALSO
23 > *    Guide to the File System Manager (from FSM 1.2 SDK)
24 > *
25 > *  TODO
26 > *    LockRng
27 > *    UnlockRng
28 > *    (CatSearch)
29 > *    (MakeFSSpec)
30 > *    (GetVolMountInfoSize)
31 > *    (GetVolMountInfo)
32 > *    (GetForeignPrivs)
33 > *    (SetForeignPrivs)
34 > */
35  
36   #include "sysdeps.h"
37  
# Line 37 | Line 40 | UnlockRng
40   #include <string.h>
41   #include <stdio.h>
42   #include <stdlib.h>
40 #include <unistd.h>
43   #include <fcntl.h>
42 #include <dirent.h>
44   #include <errno.h>
45  
46 + #ifndef WIN32
47 + #include <unistd.h>
48 + #include <dirent.h>
49 + #endif
50 +
51   #include "cpu_emulation.h"
46 #include "macos_util.h"
52   #include "emul_op.h"
53   #include "main.h"
54   #include "disk.h"
# Line 52 | Line 57 | UnlockRng
57   #include "extfs.h"
58   #include "extfs_defs.h"
59  
60 + #ifdef WIN32
61 + # include "posix_emu.h"
62 + #endif
63 +
64   #define DEBUG 0
65   #include "debug.h"
66  
# Line 62 | Line 71 | enum {
71          fsHFSProcStub = 6,
72          fsDrvStatus = 12,                               // Drive Status record
73          fsFSD = 42,                                             // File system descriptor
74 <        fsPB = 238,                                             // IOParam (for mounting)
74 >        fsPB = 238,                                             // IOParam (for mounting and renaming), also used for temporary storage
75          fsVMI = 288,                                    // VoumeMountInfoHeader (for mounting)
76          fsParseRec = 296,                               // ParsePathRec struct
77          fsReturn = 306,                                 // Area for return data of 68k routines
78          fsAllocateVCB = 562,                    // UTAllocateVCB(uint16 *sysVCBLength{a0}, uint32 *vcb{a1})
79          fsAddNewVCB = 578,                              // UTAddNewVCB(int drive_number{d0}, int16 *vRefNum{a1}, uint32 vcb{a1})
80          fsDetermineVol = 594,                   // UTDetermineVol(uint32 pb{a0}, int16 *status{a1}, int16 *more_matches{a2}, int16 *vRefNum{a3}, uint32 *vcb{a4})
81 <        fsResolveWDCB = 614,                    // UTResolveWDCB(int16 vRefNum{d0}, uint32 *wdcb{a0})
81 >        fsResolveWDCB = 614,                    // UTResolveWDCB(uint32 procID{d0}, int16 index{d1}, int16 vRefNum{d0}, uint32 *wdcb{a0})
82          fsGetDefaultVol = 632,                  // UTGetDefaultVol(uint32 wdpb{a0})
83          fsGetPathComponentName = 644,   // UTGetPathComponentName(uint32 rec{a0})
84          fsParsePathname = 656,                  // UTParsePathname(uint32 *start{a0}, uint32 name{a1})
# Line 98 | Line 107 | static bool ready = false;
107   static struct stat root_stat;
108  
109   // File system ID/media type
110 < const int16 MY_FSID = 'ba';
111 < const uint32 MY_MEDIA_TYPE = 'basi';
110 > const int16 MY_FSID = EMULATOR_ID_2;
111 > const uint32 MY_MEDIA_TYPE = EMULATOR_ID_4;
112  
113   // CNID of root and root's parent
114   const uint32 ROOT_ID = 2;
# Line 108 | Line 117 | const uint32 ROOT_PARENT_ID = 1;
117   // File system stack size
118   const int STACK_SIZE = 0x10000;
119  
120 + // Allocation block and clump size as reported to MacOS (these are of course
121 + // not the real values and have no meaning on the host OS)
122 + const int AL_BLK_SIZE = 0x4000;
123 + const int CLUMP_SIZE = 0x4000;
124 +
125   // Drive number of our pseudo-drive
126   static int drive_number;
127  
# Line 198 | Line 212 | static FSItem *find_fsitem(const char *n
212   *  Get full path (->full_path) for given FSItem
213   */
214  
201 const int MAX_PATH_LENGTH = 1024;
215   static char full_path[MAX_PATH_LENGTH];
216  
217 < static void add_path_component(const char *s)
217 > static void add_path_comp(const char *s)
218   {
219 <        int l = strlen(full_path);
207 <        if (l < MAX_PATH_LENGTH-1 && full_path[l-1] != '/') {
208 <                full_path[l] = '/';
209 <                full_path[l+1] = 0;
210 <        }
211 <        strncat(full_path, s, MAX_PATH_LENGTH-1);
219 >        add_path_component(full_path, s);
220   }
221  
222   static void get_path_for_fsitem(FSItem *p)
223   {
224 <        if (p->id == ROOT_ID) {
224 >        if (p->id == ROOT_PARENT_ID) {
225 >                full_path[0] = 0;
226 >        } else if (p->id == ROOT_ID) {
227                  strncpy(full_path, RootPath, MAX_PATH_LENGTH-1);
228                  full_path[MAX_PATH_LENGTH-1] = 0;
229          } else {
230                  get_path_for_fsitem(p->parent);
231 <                add_path_component(p->name);
231 >                add_path_comp(p->name);
232 >        }
233 > }
234 >
235 >
236 > /*
237 > *  Exchange parent CNIDs in all FSItems
238 > */
239 >
240 > static void swap_parent_ids(uint32 parent1, uint32 parent2)
241 > {
242 >        FSItem *p = first_fs_item;
243 >        while (p) {
244 >                if (p->parent_id == parent1)
245 >                        p->parent_id = parent2;
246 >                else if (p->parent_id == parent2)
247 >                        p->parent_id = parent1;
248 >                p = p->next;
249          }
250   }
251  
# Line 241 | Line 268 | static void cstr2pstr(char *dst, const c
268          *dst++ = strlen(src);
269          char c;
270          while ((c = *src++) != 0) {
271 +                // Note: we are converting host ':' characters to Mac '/' characters here
272 +                // '/' is not a path separator as this function is only used on object names
273                  if (c == ':')
274                          c = '/';
275                  *dst++ = c;
276          }
277   }
278  
250 // Convert pascal string to C string
251 static void pstr2cstr(char *dst, const char *src)
252 {
253        int size = *src++;
254        while (size--) {
255                char c = *src++;
256                if (c == '/')
257                        c = ':';
258                *dst++ = c;
259        }
260        *dst = 0;
261 }
262
279   // Convert string (no length byte) to C string, length given separately
280   static void strn2cstr(char *dst, const char *src, int size)
281   {
282          while (size--) {
283                  char c = *src++;
284 +                // Note: we are converting Mac '/' characters to host ':' characters here
285 +                // '/' is not a path separator as this function is only used on object names
286                  if (c == '/')
287                          c = ':';
288                  *dst++ = c;
# Line 322 | Line 340 | void ExtFSInit(void)
340          cstr2pstr(FS_NAME, GetString(STR_EXTFS_NAME));
341          cstr2pstr(VOLUME_NAME, GetString(STR_EXTFS_VOLUME_NAME));
342  
343 <        // Create root FSItem
343 >        // Create root's parent FSItem
344          FSItem *p = new FSItem;
345          first_fs_item = last_fs_item = p;
346          p->next = NULL;
347 +        p->id = ROOT_PARENT_ID;
348 +        p->parent_id = 0;
349 +        p->parent = NULL;
350 +        p->name[0] = 0;
351 +
352 +        // Create root FSItem
353 +        p = new FSItem;
354 +        last_fs_item->next = p;
355 +        p->next = NULL;
356 +        last_fs_item = p;
357          p->id = ROOT_ID;
358          p->parent_id = ROOT_PARENT_ID;
359 <        p->parent = NULL;
359 >        p->parent = first_fs_item;
360          strncpy(p->name, GetString(STR_EXTFS_VOLUME_NAME), 32);
361 +        p->name[31] = 0;
362  
363          // Find path for root
364          if ((RootPath = PrefsFindString("extfs")) != NULL) {
# Line 378 | Line 407 | void InstallExtFS(void)
407          // FSM present?
408          r.d[0] = gestaltFSAttr;
409          Execute68kTrap(0xa1ad, &r);     // Gestalt()
410 <        D(bug("FSAttr %ld, %08lx\n", r.d[0], r.a[0]));
411 <        if ((r.d[0] & 0xffff) || !(r.a[0] & (1 << gestaltHasFileSystemManager)))
410 >        D(bug("FSAttr %d, %08x\n", r.d[0], r.a[0]));
411 >        if ((r.d[0] & 0xffff) || !(r.a[0] & (1 << gestaltHasFileSystemManager))) {
412 >                printf("WARNING: No FSM present, disabling ExtFS\n");
413                  return;
414 +        }
415  
416          // Yes, version >=1.2?
417          r.d[0] = gestaltFSMVersion;
418          Execute68kTrap(0xa1ad, &r);     // Gestalt()
419 <        D(bug("FSMVersion %ld, %08lx\n", r.d[0], r.a[0]));
420 <        if ((r.d[0] & 0xffff) || (r.a[0] < 0x0120))
419 >        D(bug("FSMVersion %d, %08x\n", r.d[0], r.a[0]));
420 >        if ((r.d[0] & 0xffff) || (r.a[0] < 0x0120)) {
421 >                printf("WARNING: FSM <1.2 found, disabling ExtFS\n");
422                  return;
423 +        }
424  
425          D(bug("FSM present\n"));
426  
# Line 423 | Line 456 | void InstallExtFS(void)
456          WriteMacInt16(p, 0x7006); p+= 2;        // UTAllocateVCB
457          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
458          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
459 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
459 >        WriteMacInt16(p, M68K_RTS); p+= 2;
460          if (p - fs_data != fsAddNewVCB)
461                  goto fsdat_error;
462          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 433 | Line 466 | void InstallExtFS(void)
466          WriteMacInt16(p, 0x7007); p+= 2;        // UTAddNewVCB
467          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
468          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
469 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
469 >        WriteMacInt16(p, M68K_RTS); p+= 2;
470          if (p - fs_data != fsDetermineVol)
471                  goto fsdat_error;
472          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 445 | Line 478 | void InstallExtFS(void)
478          WriteMacInt16(p, 0x701d); p+= 2;        // UTDetermineVol
479          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
480          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
481 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
481 >        WriteMacInt16(p, M68K_RTS); p+= 2;
482          if (p - fs_data != fsResolveWDCB)
483                  goto fsdat_error;
484          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
485 <        WriteMacInt16(p, 0x42a7); p+= 2;        // clr.l -(sp)
486 <        WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
487 <        WriteMacInt16(p, 0x3f00); p+= 2;        // move.w d0,-(sp)
485 >        WriteMacInt16(p, 0x2f00); p+= 2;        // move.l d0,-(sp)
486 >        WriteMacInt16(p, 0x3f01); p+= 2;        // move.w d1,-(sp)
487 >        WriteMacInt16(p, 0x3f02); p+= 2;        // move.w d2,-(sp)
488          WriteMacInt16(p, 0x2f08); p+= 2;        // move.l a0,-(sp)
489          WriteMacInt16(p, 0x700e); p+= 2;        // UTResolveWDCB
490          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
491          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
492 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
492 >        WriteMacInt16(p, M68K_RTS); p+= 2;
493          if (p - fs_data != fsGetDefaultVol)
494                  goto fsdat_error;
495          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 464 | Line 497 | void InstallExtFS(void)
497          WriteMacInt16(p, 0x7012); p+= 2;        // UTGetDefaultVol
498          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
499          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
500 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
500 >        WriteMacInt16(p, M68K_RTS); p+= 2;
501          if (p - fs_data != fsGetPathComponentName)
502                  goto fsdat_error;
503          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 472 | Line 505 | void InstallExtFS(void)
505          WriteMacInt16(p, 0x701c); p+= 2;        // UTGetPathComponentName
506          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
507          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
508 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
508 >        WriteMacInt16(p, M68K_RTS); p+= 2;
509          if (p - fs_data != fsParsePathname)
510                  goto fsdat_error;
511          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 481 | Line 514 | void InstallExtFS(void)
514          WriteMacInt16(p, 0x701b); p+= 2;        // UTParsePathname
515          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
516          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
517 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
517 >        WriteMacInt16(p, M68K_RTS); p+= 2;
518          if (p - fs_data != fsDisposeVCB)
519                  goto fsdat_error;
520          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 489 | Line 522 | void InstallExtFS(void)
522          WriteMacInt16(p, 0x7008); p+= 2;        // UTDisposeVCB
523          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
524          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
525 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
525 >        WriteMacInt16(p, M68K_RTS); p+= 2;
526          if (p - fs_data != fsCheckWDRefNum)
527                  goto fsdat_error;
528          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 497 | Line 530 | void InstallExtFS(void)
530          WriteMacInt16(p, 0x7013); p+= 2;        // UTCheckWDRefNum
531          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
532          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
533 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
533 >        WriteMacInt16(p, M68K_RTS); p+= 2;
534          if (p - fs_data != fsSetDefaultVol)
535                  goto fsdat_error;
536          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 507 | Line 540 | void InstallExtFS(void)
540          WriteMacInt16(p, 0x7011); p+= 2;        // UTSetDefaultVol
541          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
542          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
543 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
543 >        WriteMacInt16(p, M68K_RTS); p+= 2;
544          if (p - fs_data != fsAllocateFCB)
545                  goto fsdat_error;
546          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 516 | Line 549 | void InstallExtFS(void)
549          WriteMacInt16(p, 0x7000); p+= 2;        // UTAllocateFCB
550          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
551          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
552 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
552 >        WriteMacInt16(p, M68K_RTS); p+= 2;
553          if (p - fs_data != fsReleaseFCB)
554                  goto fsdat_error;
555          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 524 | Line 557 | void InstallExtFS(void)
557          WriteMacInt16(p, 0x7001); p+= 2;        // UTReleaseFCB
558          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
559          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
560 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
560 >        WriteMacInt16(p, M68K_RTS); p+= 2;
561          if (p - fs_data != fsIndexFCB)
562                  goto fsdat_error;
563          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 534 | Line 567 | void InstallExtFS(void)
567          WriteMacInt16(p, 0x7004); p+= 2;        // UTIndexFCB
568          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
569          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
570 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
570 >        WriteMacInt16(p, M68K_RTS); p+= 2;
571          if (p - fs_data != fsResolveFCB)
572                  goto fsdat_error;
573          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 543 | Line 576 | void InstallExtFS(void)
576          WriteMacInt16(p, 0x7005); p+= 2;        // UTResolveFCB
577          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
578          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
579 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
579 >        WriteMacInt16(p, M68K_RTS); p+= 2;
580          if (p - fs_data != fsAdjustEOF)
581                  goto fsdat_error;
582          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 551 | Line 584 | void InstallExtFS(void)
584          WriteMacInt16(p, 0x7010); p+= 2;        // UTAdjustEOF
585          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
586          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
587 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
587 >        WriteMacInt16(p, M68K_RTS); p+= 2;
588          if (p - fs_data != fsAllocateWDCB)
589                  goto fsdat_error;
590          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 559 | Line 592 | void InstallExtFS(void)
592          WriteMacInt16(p, 0x700c); p+= 2;        // UTAllocateWDCB
593          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
594          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
595 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
595 >        WriteMacInt16(p, M68K_RTS); p+= 2;
596          if (p - fs_data != fsReleaseWDCB)
597                  goto fsdat_error;
598          WriteMacInt16(p, 0x4267); p+= 2;        // clr.w -(sp)
# Line 567 | Line 600 | void InstallExtFS(void)
600          WriteMacInt16(p, 0x700d); p+= 2;        // UTReleaseWDCB
601          WriteMacInt16(p, 0xa824); p+= 2;        // FSMgr
602          WriteMacInt16(p, 0x301f); p+= 2;        // move.w (sp)+,d0
603 <        WriteMacInt16(p, M68K_EXEC_RETURN); p+= 2;
603 >        WriteMacInt16(p, M68K_RTS); p+= 2;
604          if (p - fs_data != SIZEOF_fsdat)
605                  goto fsdat_error;
606  
# Line 591 | Line 624 | void InstallExtFS(void)
624          WriteMacInt16(fs_data + fsFSD + fsdLength, SIZEOF_FSDRec);
625          WriteMacInt16(fs_data + fsFSD + fsdVersion, fsdVersion1);
626          WriteMacInt16(fs_data + fsFSD + fileSystemFSID, MY_FSID);
627 <        memcpy(Mac2HostAddr(fs_data + fsFSD + fileSystemName), FS_NAME, 32);
627 >        Host2Mac_memcpy(fs_data + fsFSD + fileSystemName, FS_NAME, 32);
628          WriteMacInt32(fs_data + fsFSD + fileSystemCommProc, fs_data + fsCommProcStub);
629          WriteMacInt32(fs_data + fsFSD + fsdHFSCI + compInterfProc, fs_data + fsHFSProcStub);
630          WriteMacInt32(fs_data + fsFSD + fsdHFSCI + stackTop, fs_stack + STACK_SIZE);
# Line 645 | Line 678 | int16 ExtFSComm(uint16 message, uint32 p
678  
679                  case ffsGetIconMessage: {               // Get disk/drive icon
680                          if (ReadMacInt8(paramBlock + iconType) == kLargeIcon && ReadMacInt32(paramBlock + requestSize) >= sizeof(ExtFSIcon)) {
681 <                                memcpy(Mac2HostAddr(ReadMacInt32(paramBlock + iconBufferPtr)), ExtFSIcon, sizeof(ExtFSIcon));
681 >                                Host2Mac_memcpy(ReadMacInt32(paramBlock + iconBufferPtr), ExtFSIcon, sizeof(ExtFSIcon));
682                                  WriteMacInt32(paramBlock + actualSize, sizeof(ExtFSIcon));
683                                  return noErr;
684                          } else
# Line 653 | Line 686 | int16 ExtFSComm(uint16 message, uint32 p
686                  }
687  
688                  case ffsIDDiskMessage: {                // Check if volume is handled by our FS
689 <                        if (ReadMacInt16(paramBlock + ioVRefNum) == drive_number)
689 >                        if ((int16)ReadMacInt16(paramBlock + ioVRefNum) == drive_number)
690                                  return noErr;
691                          else
692                                  return extFSErr;
# Line 682 | Line 715 | static int16 get_current_dir(uint32 pb,
715          int16 result;
716  
717          // Determine volume
718 < //      D(bug("  determining volume\n"));
718 >        D(bug("  determining volume, dirID %d\n", dirID));
719          r.a[0] = pb;
720          r.a[1] = fs_data + fsReturn;
721          r.a[2] = fs_data + fsReturn + 2;
# Line 700 | Line 733 | static int16 get_current_dir(uint32 pb,
733          int16 more_matches = ReadMacInt16(fs_data + fsReturn + 2);
734          int16 vRefNum = ReadMacInt16(fs_data + fsReturn + 4);
735          uint32 vcb = ReadMacInt32(fs_data + fsReturn + 6);
736 < //      D(bug("  UTDetermineVol() returned %d, status %d\n", r.d[0], status));
737 <        result = r.d[0] & 0xffff;
736 >        D(bug("  UTDetermineVol() returned %d, status %d\n", r.d[0], status));
737 >        result = (int16)(r.d[0] & 0xffff);
738  
739          if (result == noErr) {
740                  switch (status) {
# Line 719 | Line 752 | static int16 get_current_dir(uint32 pb,
752                                          current_dir = dirID;
753                                  else {
754                                          D(bug("  resolving WDCB\n"));
755 <                                        r.d[0] = ReadMacInt16(pb + ioVRefNum);
755 >                                        r.d[0] = 0;
756 >                                        r.d[1] = 0;
757 >                                        r.d[2] = ReadMacInt16(pb + ioVRefNum);
758                                          r.a[0] = fs_data + fsReturn;
759                                          Execute68k(fs_data + fsResolveWDCB, &r);
760                                          uint32 wdcb = ReadMacInt32(fs_data + fsReturn);
761                                          D(bug("  UTResolveWDCB() returned %d, dirID %d\n", r.d[0], ReadMacInt32(wdcb + wdDirID)));
762 <                                        result = r.d[0] & 0xffff;
762 >                                        result = (int16)(r.d[0] & 0xffff);
763                                          if (result == noErr)
764                                                  current_dir = ReadMacInt32(wdcb + wdDirID);
765                                  }
# Line 740 | Line 775 | static int16 get_current_dir(uint32 pb,
775                                          r.a[0] = wdpb;
776                                          Execute68k(fs_data + fsGetDefaultVol, &r);
777                                          D(bug("  UTGetDefaultVol() returned %d, dirID %d\n", r.d[0], ReadMacInt32(wdpb + ioWDDirID)));
778 <                                        result = r.d[0] & 0xffff;
778 >                                        result = (int16)(r.d[0] & 0xffff);
779                                          if (result == noErr)
780                                                  current_dir = ReadMacInt32(wdpb + ioWDDirID);
781                                  }
# Line 766 | Line 801 | static int16 get_path_component_name(uin
801          r.a[0] = rec;
802          Execute68k(fs_data + fsGetPathComponentName, &r);
803   //      D(bug("  UTGetPathComponentName returned %d\n", r.d[0]));
804 <        return r.d[0] & 0xffff;
804 >        return (int16)(r.d[0] & 0xffff);
805   }
806  
807  
# Line 783 | Line 818 | static int16 get_item_and_path(uint32 pb
818          uint32 current_dir;
819          if ((result = get_current_dir(pb, dirID, current_dir, no_vol_name)) != noErr)
820                  return result;
821 +        D(bug("  current dir %08x\n", current_dir));
822          FSItem *p = find_fsitem_by_id(current_dir);
823          if (p == NULL)
824                  return dirNFErr;
# Line 796 | Line 832 | static int16 get_item_and_path(uint32 pb
832          WriteMacInt8(parseRec + ppFoundDelimiter, false);
833  
834          // Get length of volume name
835 < //      D(bug("  parsing pathname\n"));
835 >        D(bug("  parsing pathname\n"));
836          r.a[0] = parseRec + ppStartOffset;
837          r.a[1] = ReadMacInt32(parseRec + ppNamePtr);
838          Execute68k(fs_data + fsParsePathname, &r);
839 < //      D(bug("  UTParsePathname() returned %d, startOffset %d\n", r.d[0], ReadMacInt16(parseRec + ppStartOffset)));
840 <        result = r.d[0] & 0xffff;
839 >        D(bug("  UTParsePathname() returned %d, startOffset %d\n", r.d[0], ReadMacInt16(parseRec + ppStartOffset)));
840 >        result = (int16)(r.d[0] & 0xffff);
841          if (result == noErr) {
842  
843                  // Check for leading delimiter of the partial pathname
# Line 914 | Line 950 | static uint32 find_fcb(int16 refNum)
950   static int16 fs_mount_vol(uint32 pb)
951   {
952          D(bug(" fs_mount_vol(%08lx), vRefNum %d\n", pb, ReadMacInt16(pb + ioVRefNum)));
953 <        if (ReadMacInt16(pb + ioVRefNum) == drive_number)
953 >        if ((int16)ReadMacInt16(pb + ioVRefNum) == drive_number)
954                  return noErr;
955          else
956                  return extFSErr;
# Line 935 | Line 971 | static int16 fs_volume_mount(uint32 pb)
971          uint32 vcb = ReadMacInt32(fs_data + fsReturn + 2);
972          D(bug("  UTAllocateVCB() returned %d, vcb %08lx, size %d\n", r.d[0], vcb, sysVCBLength));
973          if (r.d[0] & 0xffff)
974 <                return r.d[0];
974 >                return (int16)r.d[0];
975  
976          // Init VCB
977          WriteMacInt16(vcb + vcbSigWord, 0x4244);
978 < #ifdef __BEOS__
978 > #if defined(__BEOS__) || defined(WIN32)
979          WriteMacInt32(vcb + vcbCrDate, root_stat.st_crtime + TIME_OFFSET);
980   #else
981          WriteMacInt32(vcb + vcbCrDate, 0);
# Line 949 | Line 985 | static int16 fs_volume_mount(uint32 pb)
985          WriteMacInt16(vcb + vcbNmFls, 1);                       //!!
986          WriteMacInt16(vcb + vcbNmRtDirs, 1);            //!!
987          WriteMacInt16(vcb + vcbNmAlBlks, 0xffff);       //!!
988 <        WriteMacInt32(vcb + vcbAlBlkSiz, 1024);
989 <        WriteMacInt32(vcb + vcbClpSiz, 1024);
988 >        WriteMacInt32(vcb + vcbAlBlkSiz, AL_BLK_SIZE);
989 >        WriteMacInt32(vcb + vcbClpSiz, CLUMP_SIZE);
990          WriteMacInt32(vcb + vcbNxtCNID, next_cnid);
991          WriteMacInt16(vcb + vcbFreeBks, 0xffff);        //!!
992 <        memcpy(Mac2HostAddr(vcb + vcbVN), VOLUME_NAME, 28);
992 >        Host2Mac_memcpy(vcb + vcbVN, VOLUME_NAME, 28);
993          WriteMacInt16(vcb + vcbFSID, MY_FSID);
994          WriteMacInt32(vcb + vcbFilCnt, 1);                      //!!
995          WriteMacInt32(vcb + vcbDirCnt, 1);                      //!!
# Line 964 | Line 1000 | static int16 fs_volume_mount(uint32 pb)
1000          r.a[0] = fs_data + fsReturn;
1001          r.a[1] = vcb;
1002          Execute68k(fs_data + fsAddNewVCB, &r);
1003 <        int16 vRefNum = ReadMacInt32(fs_data + fsReturn);
1003 >        int16 vRefNum = (int16)ReadMacInt32(fs_data + fsReturn);
1004          D(bug("  UTAddNewVCB() returned %d, vRefNum %d\n", r.d[0], vRefNum));
1005          if (r.d[0] & 0xffff)
1006 <                return r.d[0];
1006 >                return (int16)r.d[0];
1007  
1008          // Post diskInsertEvent
1009          D(bug("  posting diskInsertEvent\n"));
# Line 991 | Line 1027 | static int16 fs_unmount_vol(uint32 vcb)
1027          r.a[0] = vcb;
1028          Execute68k(fs_data + fsDisposeVCB, &r);
1029          D(bug("  UTDisposeVCB() returned %d\n", r.d[0]));
1030 <        return r.d[0];
1030 >        return (int16)r.d[0];
1031   }
1032  
1033   // Get information about a volume (HVolumeParam)
# Line 1002 | Line 1038 | static int16 fs_get_vol_info(uint32 pb,
1038          // Fill in struct
1039          if (ReadMacInt32(pb + ioNamePtr))
1040                  pstrcpy((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), VOLUME_NAME);
1041 < #ifdef __BEOS__
1041 > #if defined(__BEOS__) || defined(WIN32)
1042          WriteMacInt32(pb + ioVCrDate, root_stat.st_crtime + TIME_OFFSET);
1043   #else
1044          WriteMacInt32(pb + ioVCrDate, 0);
# Line 1013 | Line 1049 | static int16 fs_get_vol_info(uint32 pb,
1049          WriteMacInt16(pb + ioVBitMap, 0);
1050          WriteMacInt16(pb + ioAllocPtr, 0);
1051          WriteMacInt16(pb + ioVNmAlBlks, 0xffff);        //!!
1052 <        WriteMacInt32(pb + ioVAlBlkSiz, 1024);
1053 <        WriteMacInt32(pb + ioVClpSiz, 1024);
1052 >        WriteMacInt32(pb + ioVAlBlkSiz, AL_BLK_SIZE);
1053 >        WriteMacInt32(pb + ioVClpSiz, CLUMP_SIZE);
1054          WriteMacInt16(pb + ioAlBlSt, 0);
1055          WriteMacInt32(pb + ioVNxtCNID, next_cnid);
1056          WriteMacInt16(pb + ioVFrBlk, 0xffff);           //!!
# Line 1027 | Line 1063 | static int16 fs_get_vol_info(uint32 pb,
1063                  WriteMacInt32(pb + ioVWrCnt, 0);
1064                  WriteMacInt32(pb + ioVFilCnt, 1);                       //!!
1065                  WriteMacInt32(pb + ioVDirCnt, 1);                       //!!
1066 <                memset(Mac2HostAddr(pb + ioVFndrInfo), 0, 32);
1066 >                Mac_memset(pb + ioVFndrInfo, 0, 32);
1067          }
1068          return noErr;
1069   }
# Line 1047 | Line 1083 | static int16 fs_get_vol_parms(uint32 pb)
1083   //      D(bug(" fs_get_vol_parms(%08lx)\n", pb));
1084  
1085          // Return parameter block
1050        uint8 vol[SIZEOF_GetVolParmsInfoBuffer];
1051        WriteMacInt16((uint32)vol + vMVersion, 2);
1052        WriteMacInt32((uint32)vol + vMAttrib, kNoMiniFndr | kNoVNEdit | kNoLclSync | kTrshOffLine | kNoSwitchTo | kNoBootBlks | kNoSysDir | kHasExtFSVol);
1053        WriteMacInt32((uint32)vol + vMLocalHand, 0);
1054        WriteMacInt32((uint32)vol + vMServerAdr, 0);
1055        WriteMacInt32((uint32)vol + vMVolumeGrade, 0);
1056        WriteMacInt16((uint32)vol + vMForeignPrivID, 0);
1086          uint32 actual = ReadMacInt32(pb + ioReqCount);
1087 <        if (actual > sizeof(vol))
1088 <                actual = sizeof(vol);
1060 <        memcpy(Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), vol, actual);
1087 >        if (actual > SIZEOF_GetVolParmsInfoBuffer)
1088 >                actual = SIZEOF_GetVolParmsInfoBuffer;
1089          WriteMacInt32(pb + ioActCount, actual);
1090 +        uint32 p = ReadMacInt32(pb + ioBuffer);
1091 +        if (actual > vMVersion) WriteMacInt16(p + vMVersion, 2);
1092 +        if (actual > vMAttrib) WriteMacInt32(p + vMAttrib, kNoMiniFndr | kNoVNEdit | kNoLclSync | kTrshOffLine | kNoSwitchTo | kNoBootBlks | kNoSysDir | kHasExtFSVol);
1093 +        if (actual > vMLocalHand) WriteMacInt32(p + vMLocalHand, 0);
1094 +        if (actual > vMServerAdr) WriteMacInt32(p + vMServerAdr, 0);
1095 +        if (actual > vMVolumeGrade) WriteMacInt32(p + vMVolumeGrade, 0);
1096 +        if (actual > vMForeignPrivID) WriteMacInt16(p + vMForeignPrivID, 0);
1097          return noErr;
1098   }
1099  
# Line 1073 | Line 1108 | static int16 fs_get_vol(uint32 pb)
1108          r.a[0] = pb;
1109          Execute68k(fs_data + fsGetDefaultVol, &r);
1110          D(bug("  UTGetDefaultVol() returned %d\n", r.d[0]));
1111 <        return r.d[0];
1111 >        return (int16)r.d[0];
1112   }
1113  
1114   // Set default volume (WDParam)
1115   static int16 fs_set_vol(uint32 pb, bool hfs, uint32 vcb)
1116   {
1117 <        D(bug(" fs_set_vol(%08lx), vRefNum %d, name %#s, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), ReadMacInt32(pb + ioWDDirID)));
1117 >        D(bug(" fs_set_vol(%08lx), vRefNum %d, name %.31s, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), ReadMacInt32(pb + ioWDDirID)));
1118          M68kRegisters r;
1119  
1120          // Determine parameters
# Line 1129 | Line 1164 | static int16 fs_set_vol(uint32 pb, bool
1164          r.d[2] = refNum;
1165          Execute68k(fs_data + fsSetDefaultVol, &r);
1166          D(bug("  UTSetDefaultVol() returned %d\n", r.d[0]));
1167 <        return r.d[0];
1167 >        return (int16)r.d[0];
1168   }
1169  
1170   // Query file attributes (HFileParam)
1171   static int16 fs_get_file_info(uint32 pb, bool hfs, uint32 dirID)
1172   {
1173 <        D(bug(" fs_get_file_info(%08lx), vRefNum %d, name %#s, idx %d, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), ReadMacInt16(pb + ioFDirIndex), dirID));
1173 >        D(bug(" fs_get_file_info(%08lx), vRefNum %d, name %.31s, idx %d, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), ReadMacInt16(pb + ioFDirIndex), dirID));
1174  
1175          FSItem *fs_item;
1176          int16 dir_index = ReadMacInt16(pb + ioFDirIndex);
1177 <        if (dir_index == 0) {   // Query item specified by ioDirID and ioNamePtr
1177 >        if (dir_index <= 0) {           // Query item specified by ioDirID and ioNamePtr
1178  
1179                  // Find FSItem for given file
1180                  int16 result = get_item_and_path(pb, dirID, fs_item);
# Line 1171 | Line 1206 | read_next_de:
1206                                  return fnfErr;
1207                          }
1208                          if (de->d_name[0] == '.')
1209 <                                goto read_next_de;      // Suppress name beginning with '.' (MacOS could interpret these as driver names)
1209 >                                goto read_next_de;      // Suppress names beginning with '.' (MacOS could interpret these as driver names)
1210                          //!! suppress directories
1211                  }
1212 <                add_path_component(de->d_name);
1212 >                add_path_comp(de->d_name);
1213  
1214                  // Get FSItem for queried item
1215                  fs_item = find_fsitem(de->d_name, p);
# Line 1195 | Line 1230 | read_next_de:
1230          WriteMacInt8(pb + ioFlAttrib, access(full_path, W_OK) == 0 ? 0 : faLocked);
1231          WriteMacInt32(pb + ioDirID, fs_item->id);
1232  
1233 < #ifdef __BEOS__
1233 > #if defined(__BEOS__) || defined(WIN32)
1234          WriteMacInt32(pb + ioFlCrDat, st.st_crtime + TIME_OFFSET);
1235   #else
1236          WriteMacInt32(pb + ioFlCrDat, 0);
1237   #endif
1238          WriteMacInt32(pb + ioFlMdDat, st.st_mtime + TIME_OFFSET);
1239  
1240 <        memset(Mac2HostAddr(pb + ioFlFndrInfo), 0, SIZEOF_FInfo);
1206 <        uint32 type, creator;   // pb may point to kernel space, but stack is switched
1207 <        get_finder_type(full_path, type, creator);
1208 <        WriteMacInt32(pb + ioFlFndrInfo + fdType, type);
1209 <        WriteMacInt32(pb + ioFlFndrInfo + fdCreator, creator);
1210 <        uint16 fflags;
1211 <        get_finder_flags(full_path, fflags);
1212 <        WriteMacInt16(pb + ioFlFndrInfo + fdFlags, fflags);
1240 >        get_finfo(full_path, pb + ioFlFndrInfo, hfs ? pb + ioFlXFndrInfo : 0, false);
1241  
1242          WriteMacInt16(pb + ioFlStBlk, 0);
1243          WriteMacInt32(pb + ioFlLgLen, st.st_size);
1244 <        WriteMacInt32(pb + ioFlPyLen, (st.st_size + 1023) & ~1023);
1244 >        WriteMacInt32(pb + ioFlPyLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1245          WriteMacInt16(pb + ioFlRStBlk, 0);
1246          uint32 rf_size = get_rfork_size(full_path);
1247          WriteMacInt32(pb + ioFlRLgLen, rf_size);
1248 <        WriteMacInt32(pb + ioFlRPyLen, (rf_size + 1023) & ~1023);
1248 >        WriteMacInt32(pb + ioFlRPyLen, (rf_size | (AL_BLK_SIZE - 1)) + 1);
1249  
1250          if (hfs) {
1251                  WriteMacInt32(pb + ioFlBkDat, 0);
1224                memset(Mac2HostAddr(pb + ioFlXFndrInfo), 0, SIZEOF_FXInfo);
1252                  WriteMacInt32(pb + ioFlParID, fs_item->parent_id);
1253                  WriteMacInt32(pb + ioFlClpSiz, 0);
1254          }
# Line 1231 | Line 1258 | read_next_de:
1258   // Set file attributes (HFileParam)
1259   static int16 fs_set_file_info(uint32 pb, bool hfs, uint32 dirID)
1260   {
1261 <        D(bug(" fs_set_file_info(%08lx), vRefNum %d, name %#s, idx %d, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), ReadMacInt16(pb + ioFDirIndex), dirID));
1261 >        D(bug(" fs_set_file_info(%08lx), vRefNum %d, name %.31s, idx %d, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), ReadMacInt16(pb + ioFDirIndex), dirID));
1262  
1263          // Find FSItem for given file/dir
1264          FSItem *fs_item;
# Line 1246 | Line 1273 | static int16 fs_set_file_info(uint32 pb,
1273          if (S_ISDIR(st.st_mode))
1274                  return fnfErr;
1275  
1276 <        // Set attributes
1277 <        set_finder_type(full_path, ReadMacInt32(pb + ioFlFndrInfo + fdType), ReadMacInt32(pb + ioFlFndrInfo + fdCreator));
1278 <        set_finder_flags(full_path, ReadMacInt16(pb + ioFlFndrInfo + fdFlags));
1276 >        // Set Finder info
1277 >        set_finfo(full_path, pb + ioFlFndrInfo, hfs ? pb + ioFlXFndrInfo : 0, false);
1278 >
1279          //!! times
1280          return noErr;
1281   }
# Line 1256 | Line 1283 | static int16 fs_set_file_info(uint32 pb,
1283   // Query file/directory attributes
1284   static int16 fs_get_cat_info(uint32 pb)
1285   {
1286 <        D(bug(" fs_get_cat_info(%08lx), vRefNum %d, name %#s, idx %d, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), ReadMacInt16(pb + ioFDirIndex), ReadMacInt32(pb + ioDirID)));
1286 >        D(bug(" fs_get_cat_info(%08lx), vRefNum %d, name %.31s, idx %d, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), ReadMacInt16(pb + ioFDirIndex), ReadMacInt32(pb + ioDirID)));
1287  
1288          FSItem *fs_item;
1289          int16 dir_index = ReadMacInt16(pb + ioFDirIndex);
1290 <        if (dir_index == -1) {          // Query directory specified by ioDirID
1290 >        if (dir_index < 0) {                    // Query directory specified by ioDirID
1291  
1292                  // Find FSItem for directory
1293                  fs_item = find_fsitem_by_id(ReadMacInt32(pb + ioDrDirID));
# Line 1300 | Line 1327 | read_next_de:
1327                                  return fnfErr;
1328                          }
1329                          if (de->d_name[0] == '.')
1330 <                                goto read_next_de;      // Suppress name beginning with '.' (MacOS could interpret these as driver names)
1330 >                                goto read_next_de;      // Suppress names beginning with '.' (MacOS could interpret these as driver names)
1331                  }
1332 <                add_path_component(de->d_name);
1332 >                add_path_comp(de->d_name);
1333  
1334                  // Get FSItem for queried item
1335                  fs_item = find_fsitem(de->d_name, p);
# Line 1325 | Line 1352 | read_next_de:
1352          WriteMacInt8(pb + ioACUser, 0);
1353          WriteMacInt32(pb + ioDirID, fs_item->id);
1354          WriteMacInt32(pb + ioFlParID, fs_item->parent_id);
1355 < #ifdef __BEOS__
1355 > #if defined(__BEOS__) || defined(WIN32)
1356          WriteMacInt32(pb + ioFlCrDat, st.st_crtime + TIME_OFFSET);
1357   #else
1358          WriteMacInt32(pb + ioFlCrDat, 0);
# Line 1336 | Line 1363 | read_next_de:
1363                  fs_item->mtime = mtime;
1364                  cached = false;
1365          }
1366 <        WriteMacInt32(pb + ioFlMdDat, mtime);
1366 >        WriteMacInt32(pb + ioFlMdDat, mtime + TIME_OFFSET);
1367          WriteMacInt32(pb + ioFlBkDat, 0);
1368 +
1369 +        get_finfo(full_path, pb + ioFlFndrInfo, pb + ioFlXFndrInfo, S_ISDIR(st.st_mode));
1370 +
1371          if (S_ISDIR(st.st_mode)) {
1342                memset(Mac2HostAddr(pb + ioDrUsrWds), 0, SIZEOF_DInfo);
1343                memset(Mac2HostAddr(pb + ioDrFndrInfo), 0, SIZEOF_DXInfo);
1344                uint16 fflags;  // pb may point to kernel space, but stack is switched
1345                get_finder_flags(full_path, fflags);
1346                WriteMacInt16(pb + ioDrUsrWds + frFlags, fflags);
1372  
1373                  // Determine number of files in directory (cached)
1374                  int count;
# Line 1358 | Line 1383 | read_next_de:
1383                                          de = readdir(d);
1384                                          if (de == NULL)
1385                                                  break;
1386 +                                        if (de->d_name[0] == '.')
1387 +                                                continue;       // Suppress names beginning with '.'
1388                                          count++;
1389                                  }
1390                                  closedir(d);
# Line 1366 | Line 1393 | read_next_de:
1393                  }
1394                  WriteMacInt16(pb + ioDrNmFls, count);
1395          } else {
1369                memset(Mac2HostAddr(pb + ioFlFndrInfo), 0, SIZEOF_FInfo);
1370                memset(Mac2HostAddr(pb + ioFlXFndrInfo), 0, SIZEOF_FXInfo);
1371                uint32 type, creator;   // pb may point to kernel space, but stack is switched
1372                get_finder_type(full_path, type, creator);
1373                WriteMacInt32(pb + ioFlFndrInfo + fdType, type);
1374                WriteMacInt32(pb + ioFlFndrInfo + fdCreator, creator);
1375                uint16 fflags;
1376                get_finder_flags(full_path, fflags);
1377                WriteMacInt16(pb + ioFlFndrInfo + fdFlags, fflags);
1396                  WriteMacInt16(pb + ioFlStBlk, 0);
1397                  WriteMacInt32(pb + ioFlLgLen, st.st_size);
1398 <                WriteMacInt32(pb + ioFlPyLen, (st.st_size + 1023) & ~1023);
1398 >                WriteMacInt32(pb + ioFlPyLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1399                  WriteMacInt16(pb + ioFlRStBlk, 0);
1400                  uint32 rf_size = get_rfork_size(full_path);
1401                  WriteMacInt32(pb + ioFlRLgLen, rf_size);
1402 <                WriteMacInt32(pb + ioFlRPyLen, (rf_size + 1023) & ~1023);
1402 >                WriteMacInt32(pb + ioFlRPyLen, (rf_size | (AL_BLK_SIZE - 1)) + 1);
1403                  WriteMacInt32(pb + ioFlClpSiz, 0);
1404          }
1405          return noErr;
# Line 1390 | Line 1408 | read_next_de:
1408   // Set file/directory attributes
1409   static int16 fs_set_cat_info(uint32 pb)
1410   {
1411 <        D(bug(" fs_set_cat_info(%08lx), vRefNum %d, name %#s, idx %d, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), ReadMacInt16(pb + ioFDirIndex), ReadMacInt32(pb + ioDirID)));
1411 >        D(bug(" fs_set_cat_info(%08lx), vRefNum %d, name %.31s, idx %d, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), ReadMacInt16(pb + ioFDirIndex), ReadMacInt32(pb + ioDirID)));
1412  
1413          // Find FSItem for given file/dir
1414          FSItem *fs_item;
# Line 1403 | Line 1421 | static int16 fs_set_cat_info(uint32 pb)
1421          if (stat(full_path, &st) < 0)
1422                  return errno2oserr();
1423  
1424 <        // Set attributes
1425 <        if (S_ISDIR(st.st_mode))
1426 <                set_finder_flags(full_path, ReadMacInt16(pb + ioDrUsrWds + frFlags));
1409 <        else {
1410 <                set_finder_type(full_path, ReadMacInt32(pb + ioFlFndrInfo + fdType), ReadMacInt32(pb + ioFlFndrInfo + fdCreator));
1411 <                set_finder_flags(full_path, ReadMacInt16(pb + ioFlFndrInfo + fdFlags));
1412 <        }
1424 >        // Set Finder info
1425 >        set_finfo(full_path, pb + ioFlFndrInfo, pb + ioFlXFndrInfo, S_ISDIR(st.st_mode));
1426 >
1427          //!! times
1428          return noErr;
1429   }
# Line 1417 | Line 1431 | static int16 fs_set_cat_info(uint32 pb)
1431   // Open file
1432   static int16 fs_open(uint32 pb, uint32 dirID, uint32 vcb, bool resource_fork)
1433   {
1434 <        D(bug(" fs_open(%08lx), %s, vRefNum %d, name %#s, dirID %d, perm %d\n", pb, resource_fork ? "rsrc" : "data", ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), dirID, ReadMacInt8(pb + ioPermssn)));
1434 >        D(bug(" fs_open(%08lx), %s, vRefNum %d, name %.31s, dirID %d, perm %d\n", pb, resource_fork ? "rsrc" : "data", ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), dirID, ReadMacInt8(pb + ioPermssn)));
1435          M68kRegisters r;
1436  
1437          // Find FSItem for given file
# Line 1456 | Line 1470 | static int16 fs_open(uint32 pb, uint32 d
1470                  if (access(full_path, F_OK))
1471                          return fnfErr;
1472                  fd = open_rfork(full_path, flag);
1473 <                if (fd > 0) {
1474 <                        if (fstat(fd, &st) < 0)
1473 >                if (fd >= 0) {
1474 >                        if (fstat(fd, &st) < 0) {
1475 >                                close(fd);
1476                                  return errno2oserr();
1477 +                        }
1478                  } else {        // Resource fork not supported, silently ignore it ("pseudo" resource fork)
1479                          st.st_size = 0;
1480                          st.st_mode = 0;
# Line 1467 | Line 1483 | static int16 fs_open(uint32 pb, uint32 d
1483                  fd = open(full_path, flag);
1484                  if (fd < 0)
1485                          return errno2oserr();
1486 <                if (fstat(fd, &st) < 0)
1486 >                if (fstat(fd, &st) < 0) {
1487 >                        close(fd);
1488                          return errno2oserr();
1489 +                }
1490          }
1491  
1492          // File open, allocate FCB
# Line 1480 | Line 1498 | static int16 fs_open(uint32 pb, uint32 d
1498          D(bug("  UTAllocateFCB() returned %d, fRefNum %d, fcb %08lx\n", r.d[0], ReadMacInt16(pb + ioRefNum), fcb));
1499          if (r.d[0] & 0xffff) {
1500                  close(fd);
1501 <                return r.d[0];
1501 >                return (int16)r.d[0];
1502          }
1503  
1504          // Initialize FCB, fd is stored in fcbCatPos
1505          WriteMacInt32(fcb + fcbFlNm, fs_item->id);
1506          WriteMacInt8(fcb + fcbFlags, ((flag == O_WRONLY || flag == O_RDWR) ? fcbWriteMask : 0) | (resource_fork ? fcbResourceMask : 0) | (write_ok ? 0 : fcbFileLockedMask));
1507          WriteMacInt32(fcb + fcbEOF, st.st_size);
1508 <        WriteMacInt32(fcb + fcbPLen, (st.st_size + 1023) & ~1023);
1508 >        WriteMacInt32(fcb + fcbPLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1509          WriteMacInt32(fcb + fcbCrPs, 0);
1510          WriteMacInt32(fcb + fcbVPtr, vcb);
1511 <        WriteMacInt32(fcb + fcbClmpSize, 1024);
1512 <        uint32 type, creator;   // fcb may point to kernel space, but stack is switched
1513 <        get_finder_type(full_path, type, creator);
1514 <        WriteMacInt32(fcb + fcbFType, type);
1511 >        WriteMacInt32(fcb + fcbClmpSize, CLUMP_SIZE);
1512 >
1513 >        get_finfo(full_path, fs_data + fsPB, 0, false);
1514 >        WriteMacInt32(fcb + fcbFType, ReadMacInt32(fs_data + fsPB + fdType));
1515 >
1516          WriteMacInt32(fcb + fcbCatPos, fd);
1517          WriteMacInt32(fcb + fcbDirID, fs_item->parent_id);
1518          cstr2pstr((char *)Mac2HostAddr(fcb + fcbCName), fs_item->name);
# Line 1530 | Line 1549 | static int16 fs_close(uint32 pb)
1549          r.d[0] = ReadMacInt16(pb + ioRefNum);
1550          Execute68k(fs_data + fsReleaseFCB, &r);
1551          D(bug("  UTReleaseFCB() returned %d\n", r.d[0]));
1552 <        return r.d[0];
1552 >        return (int16)r.d[0];
1553   }
1554  
1555   // Query information about FCB (FCBPBRec)
# Line 1549 | Line 1568 | static int16 fs_get_fcb_info(uint32 pb,
1568  
1569                  // Find FCB by index
1570                  WriteMacInt16(pb + ioRefNum, 0);
1571 <                for (int i=0; i<ReadMacInt16(pb + ioFCBIndx); i++) {
1571 >                for (int i=0; i<(int)ReadMacInt16(pb + ioFCBIndx); i++) {
1572                          D(bug("  indexing FCBs\n"));
1573                          r.a[0] = vcb;
1574                          r.a[1] = pb + ioRefNum;
# Line 1558 | Line 1577 | static int16 fs_get_fcb_info(uint32 pb,
1577                          fcb = ReadMacInt32(fs_data + fsReturn);
1578                          D(bug("  UTIndexFCB() returned %d, fcb %p\n", r.d[0], fcb));
1579                          if (r.d[0] & 0xffff)
1580 <                                return r.d[0];
1580 >                                return (int16)r.d[0];
1581                  }
1582          }
1583          if (fcb == 0)
# Line 1606 | Line 1625 | static int16 fs_get_eof(uint32 pb)
1625  
1626          // Adjust FCBs
1627          WriteMacInt32(fcb + fcbEOF, st.st_size);
1628 <        WriteMacInt32(fcb + fcbPLen, (st.st_size + 1023) & ~1023);
1628 >        WriteMacInt32(fcb + fcbPLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1629          WriteMacInt32(pb + ioMisc, st.st_size);
1630          D(bug("  adjusting FCBs\n"));
1631          r.d[0] = ReadMacInt16(pb + ioRefNum);
# Line 1641 | Line 1660 | static int16 fs_set_eof(uint32 pb)
1660  
1661          // Adjust FCBs
1662          WriteMacInt32(fcb + fcbEOF, size);
1663 <        WriteMacInt32(fcb + fcbPLen, (size + 1023) & ~1023);
1663 >        WriteMacInt32(fcb + fcbPLen, (size | (AL_BLK_SIZE - 1)) + 1);
1664          D(bug("  adjusting FCBs\n"));
1665          r.d[0] = ReadMacInt16(pb + ioRefNum);
1666          Execute68k(fs_data + fsAdjustEOF, &r);
# Line 1704 | Line 1723 | static int16 fs_set_fpos(uint32 pb)
1723                          if (lseek(fd, ReadMacInt32(pb + ioPosOffset), SEEK_SET) < 0)
1724                                  return posErr;
1725                          break;
1726 +                case fsFromLEOF:
1727 +                        if (lseek(fd, (int32)ReadMacInt32(pb + ioPosOffset), SEEK_END) < 0)
1728 +                                return posErr;
1729 +                        break;
1730                  case fsFromMark:
1731 <                        if (lseek(fd, ReadMacInt32(pb + ioPosOffset), SEEK_CUR) < 0)
1731 >                        if (lseek(fd, (int32)ReadMacInt32(pb + ioPosOffset), SEEK_CUR) < 0)
1732                                  return posErr;
1733 +                        break;
1734                  default:
1735                          break;
1736          }
# Line 1721 | Line 1745 | static int16 fs_read(uint32 pb)
1745   {
1746          D(bug(" fs_read(%08lx), refNum %d, buffer %p, count %d, posMode %d, posOffset %d\n", pb, ReadMacInt16(pb + ioRefNum), ReadMacInt32(pb + ioBuffer), ReadMacInt32(pb + ioReqCount), ReadMacInt16(pb + ioPosMode), ReadMacInt32(pb + ioPosOffset)));
1747  
1748 +        // Check parameters
1749 +        if ((int32)ReadMacInt32(pb + ioReqCount) < 0)
1750 +                return paramErr;
1751 +
1752          // Find FCB and fd for file
1753          uint32 fcb = find_fcb(ReadMacInt16(pb + ioRefNum));
1754          if (fcb == 0)
# Line 1752 | Line 1780 | static int16 fs_read(uint32 pb)
1780          }
1781  
1782          // Read
1783 <        size_t actual = extfs_read(fd, Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), ReadMacInt32(pb + ioReqCount));
1783 >        ssize_t actual = extfs_read(fd, Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), ReadMacInt32(pb + ioReqCount));
1784 >        int16 read_err = errno2oserr();
1785          D(bug("  actual %d\n", actual));
1786 <        WriteMacInt32(pb + ioActCount, actual);
1786 >        WriteMacInt32(pb + ioActCount, actual >= 0 ? actual : 0);
1787          uint32 pos = lseek(fd, 0, SEEK_CUR);
1788          WriteMacInt32(fcb + fcbCrPs, pos);
1789          WriteMacInt32(pb + ioPosOffset, pos);
1790 <        if (actual != ReadMacInt32(pb + ioReqCount))
1791 <                if (errno)
1763 <                        return errno2oserr();
1764 <                else
1765 <                        return eofErr;
1790 >        if (actual != (ssize_t)ReadMacInt32(pb + ioReqCount))
1791 >                return actual < 0 ? read_err : eofErr;
1792          else
1793                  return noErr;
1794   }
# Line 1772 | Line 1798 | static int16 fs_write(uint32 pb)
1798   {
1799          D(bug(" fs_write(%08lx), refNum %d, buffer %p, count %d, posMode %d, posOffset %d\n", pb, ReadMacInt16(pb + ioRefNum), ReadMacInt32(pb + ioBuffer), ReadMacInt32(pb + ioReqCount), ReadMacInt16(pb + ioPosMode), ReadMacInt32(pb + ioPosOffset)));
1800  
1801 +        // Check parameters
1802 +        if ((int32)ReadMacInt32(pb + ioReqCount) < 0)
1803 +                return paramErr;
1804 +
1805          // Find FCB and fd for file
1806          uint32 fcb = find_fcb(ReadMacInt16(pb + ioRefNum));
1807          if (fcb == 0)
# Line 1803 | Line 1833 | static int16 fs_write(uint32 pb)
1833          }
1834  
1835          // Write
1836 <        size_t actual = extfs_write(fd, Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), ReadMacInt32(pb + ioReqCount));
1836 >        ssize_t actual = extfs_write(fd, Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), ReadMacInt32(pb + ioReqCount));
1837 >        int16 write_err = errno2oserr();
1838          D(bug("  actual %d\n", actual));
1839 <        WriteMacInt32(pb + ioActCount, actual);
1839 >        WriteMacInt32(pb + ioActCount, actual >= 0 ? actual : 0);
1840          uint32 pos = lseek(fd, 0, SEEK_CUR);
1841          WriteMacInt32(fcb + fcbCrPs, pos);
1842          WriteMacInt32(pb + ioPosOffset, pos);
1843 <        if (actual != ReadMacInt32(pb + ioReqCount))
1844 <                return errno2oserr();
1843 >        if (actual != (ssize_t)ReadMacInt32(pb + ioReqCount))
1844 >                return write_err;
1845          else
1846                  return noErr;
1847   }
# Line 1818 | Line 1849 | static int16 fs_write(uint32 pb)
1849   // Create file
1850   static int16 fs_create(uint32 pb, uint32 dirID)
1851   {
1852 <        D(bug(" fs_create(%08lx), vRefNum %d, name %#s, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), dirID));
1852 >        D(bug(" fs_create(%08lx), vRefNum %d, name %.31s, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), dirID));
1853  
1854          // Find FSItem for given file
1855          FSItem *fs_item;
# Line 1831 | Line 1862 | static int16 fs_create(uint32 pb, uint32
1862                  return dupFNErr;
1863  
1864          // Create file
1865 <        int fd = creat(full_path, 0664);
1865 >        int fd = creat(full_path, 0666);
1866          if (fd < 0)
1867                  return errno2oserr();
1868          else {
# Line 1843 | Line 1874 | static int16 fs_create(uint32 pb, uint32
1874   // Create directory
1875   static int16 fs_dir_create(uint32 pb)
1876   {
1877 <        D(bug(" fs_dir_create(%08lx), vRefNum %d, name %#s, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), ReadMacInt32(pb + ioDirID)));
1877 >        D(bug(" fs_dir_create(%08lx), vRefNum %d, name %.31s, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), ReadMacInt32(pb + ioDirID)));
1878  
1879          // Find FSItem for given directory
1880          FSItem *fs_item;
# Line 1856 | Line 1887 | static int16 fs_dir_create(uint32 pb)
1887                  return dupFNErr;
1888  
1889          // Create directory
1890 <        if (mkdir(full_path, 0775) < 0)
1890 >        if (mkdir(full_path, 0777) < 0)
1891                  return errno2oserr();
1892          else {
1893                  WriteMacInt32(pb + ioDirID, fs_item->id);
# Line 1867 | Line 1898 | static int16 fs_dir_create(uint32 pb)
1898   // Delete file/directory
1899   static int16 fs_delete(uint32 pb, uint32 dirID)
1900   {
1901 <        D(bug(" fs_delete(%08lx), vRefNum %d, name %#s, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), dirID));
1901 >        D(bug(" fs_delete(%08lx), vRefNum %d, name %.31s, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), dirID));
1902  
1903          // Find FSItem for given file/dir
1904          FSItem *fs_item;
# Line 1876 | Line 1907 | static int16 fs_delete(uint32 pb, uint32
1907                  return result;
1908  
1909          // Delete file
1910 <        if (remove(full_path) < 0) {
1911 <                int16 err = errno2oserr();
1912 <                if (errno == EISDIR) {  // Workaround for BeOS bug
1882 <                        if (rmdir(full_path) < 0)
1883 <                                return errno2oserr();
1884 <                        else
1885 <                                return noErr;
1886 <                } else
1887 <                        return err;
1888 <        } else
1910 >        if (!extfs_remove(full_path))
1911 >                return errno2oserr();
1912 >        else
1913                  return noErr;
1914   }
1915  
1916   // Rename file/directory
1917   static int16 fs_rename(uint32 pb, uint32 dirID)
1918   {
1919 <        D(bug(" fs_rename(%08lx), vRefNum %d, name %#s, dirID %d, new name %#s\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), dirID, Mac2HostAddr(ReadMacInt32(pb + ioMisc))));
1919 >        D(bug(" fs_rename(%08lx), vRefNum %d, name %.31s, dirID %d, new name %.31s\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), dirID, Mac2HostAddr(ReadMacInt32(pb + ioMisc) + 1)));
1920  
1921          // Find path of given file/dir
1922          FSItem *fs_item;
# Line 1905 | Line 1929 | static int16 fs_rename(uint32 pb, uint32
1929          strcpy(old_path, full_path);
1930  
1931          // Find path for new name
1932 <        uint8 new_pb[SIZEOF_IOParam];
1933 <        memcpy(new_pb, Mac2HostAddr(pb), SIZEOF_IOParam);
1910 <        WriteMacInt32((uint32)new_pb + ioNamePtr, ReadMacInt32(pb + ioMisc));
1932 >        Mac2Mac_memcpy(fs_data + fsPB, pb, SIZEOF_IOParam);
1933 >        WriteMacInt32(fs_data + fsPB + ioNamePtr, ReadMacInt32(pb + ioMisc));
1934          FSItem *new_item;
1935 <        result = get_item_and_path((uint32)new_pb, dirID, new_item);
1935 >        result = get_item_and_path(fs_data + fsPB, dirID, new_item);
1936          if (result != noErr)
1937                  return result;
1938  
# Line 1919 | Line 1942 | static int16 fs_rename(uint32 pb, uint32
1942  
1943          // Rename item
1944          D(bug("  renaming %s -> %s\n", old_path, full_path));
1945 <        if (rename(old_path, full_path) < 0)
1945 >        if (!extfs_rename(old_path, full_path))
1946                  return errno2oserr();
1947          else {
1948                  // The ID of the old file/dir has to stay the same, so we swap the IDs of the FSItems
1949 +                swap_parent_ids(fs_item->id, new_item->id);
1950                  uint32 t = fs_item->id;
1951                  fs_item->id = new_item->id;
1952                  new_item->id = t;
# Line 1933 | Line 1957 | static int16 fs_rename(uint32 pb, uint32
1957   // Move file/directory (CMovePBRec)
1958   static int16 fs_cat_move(uint32 pb)
1959   {
1960 <        D(bug(" fs_cat_move(%08lx), vRefNum %d, name %#s, dirID %d, new name %#s, new dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), ReadMacInt32(pb + ioDirID), Mac2HostAddr(ReadMacInt32(pb + ioNewName)), ReadMacInt32(pb + ioNewDirID)));
1960 >        D(bug(" fs_cat_move(%08lx), vRefNum %d, name %.31s, dirID %d, new name %.31s, new dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), ReadMacInt32(pb + ioDirID), Mac2HostAddr(ReadMacInt32(pb + ioNewName) + 1), ReadMacInt32(pb + ioNewDirID)));
1961  
1962          // Find path of given file/dir
1963          FSItem *fs_item;
# Line 1946 | Line 1970 | static int16 fs_cat_move(uint32 pb)
1970          strcpy(old_path, full_path);
1971  
1972          // Find path for new directory
1973 <        uint8 new_pb[SIZEOF_IOParam];
1974 <        memcpy(new_pb, Mac2HostAddr(pb), SIZEOF_IOParam);
1951 <        WriteMacInt32((uint32)new_pb + ioNamePtr, ReadMacInt32(pb + ioNewName));
1973 >        Mac2Mac_memcpy(fs_data + fsPB, pb, SIZEOF_IOParam);
1974 >        WriteMacInt32(fs_data + fsPB + ioNamePtr, ReadMacInt32(pb + ioNewName));
1975          FSItem *new_dir_item;
1976 <        result = get_item_and_path((uint32)new_pb, ReadMacInt32(pb + ioNewDirID), new_dir_item);
1976 >        result = get_item_and_path(fs_data + fsPB, ReadMacInt32(pb + ioNewDirID), new_dir_item);
1977          if (result != noErr)
1978                  return result;
1979  
1980          // Append old file/dir name
1981 <        add_path_component(fs_item->name);
1981 >        add_path_comp(fs_item->name);
1982  
1983          // Does the new name already exist?
1984          if (access(full_path, F_OK) == 0)
# Line 1963 | Line 1986 | static int16 fs_cat_move(uint32 pb)
1986  
1987          // Move item
1988          D(bug("  moving %s -> %s\n", old_path, full_path));
1989 <        if (rename(old_path, full_path) < 0)
1989 >        if (!extfs_rename(old_path, full_path))
1990                  return errno2oserr();
1991          else {
1992                  // The ID of the old file/dir has to stay the same, so we swap the IDs of the FSItems
1993                  FSItem *new_item = find_fsitem(fs_item->name, new_dir_item);
1994                  if (new_item) {
1995 +                        swap_parent_ids(fs_item->id, new_item->id);
1996                          uint32 t = fs_item->id;
1997                          fs_item->id = new_item->id;
1998                          new_item->id = t;
# Line 1980 | Line 2004 | static int16 fs_cat_move(uint32 pb)
2004   // Open working directory (WDParam)
2005   static int16 fs_open_wd(uint32 pb)
2006   {
2007 <        D(bug(" fs_open_wd(%08lx), vRefNum %d, name %#s, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), ReadMacInt32(pb + ioWDDirID)));
2007 >        D(bug(" fs_open_wd(%08lx), vRefNum %d, name %.31s, dirID %d\n", pb, ReadMacInt16(pb + ioVRefNum), Mac2HostAddr(ReadMacInt32(pb + ioNamePtr) + 1), ReadMacInt32(pb + ioWDDirID)));
2008          M68kRegisters r;
2009  
2010          // Allocate WDCB
2011          D(bug("  allocating WDCB\n"));
2012          r.a[0] = pb;
2013          Execute68k(fs_data + fsAllocateWDCB, &r);
2014 <        D(bug("  UTAllocateWDCB returned %d\n", r.d[0]));
2015 <        return r.d[0];
2014 >        D(bug("  UTAllocateWDCB returned %d, refNum is %d\n", r.d[0], ReadMacInt16(pb + ioVRefNum)));
2015 >        return (int16)r.d[0];
2016   }
2017  
2018   // Close working directory (WDParam)
# Line 2002 | Line 2026 | static int16 fs_close_wd(uint32 pb)
2026          r.d[0] = ReadMacInt16(pb + ioVRefNum);
2027          Execute68k(fs_data + fsReleaseWDCB, &r);
2028          D(bug("  UTReleaseWDCB returned %d\n", r.d[0]));
2029 <        return r.d[0];
2029 >        return (int16)r.d[0];
2030   }
2031  
2032   // Query information about working directory (WDParam)
# Line 2016 | Line 2040 | static int16 fs_get_wd_info(uint32 pb, u
2040                  WriteMacInt32(pb + ioWDProcID, 0);
2041                  WriteMacInt16(pb + ioWDVRefNum, ReadMacInt16(vcb + vcbVRefNum));
2042                  if (ReadMacInt32(pb + ioNamePtr))
2043 <                        memcpy(Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), Mac2HostAddr(vcb + vcbVN), 28);
2043 >                        Mac2Mac_memcpy(ReadMacInt32(pb + ioNamePtr), vcb + vcbVN, 28);
2044                  WriteMacInt32(pb + ioWDDirID, ROOT_ID);
2045                  return noErr;
2046          }
# Line 2031 | Line 2055 | static int16 fs_get_wd_info(uint32 pb, u
2055          uint32 wdcb = ReadMacInt32(fs_data + fsReturn);
2056          D(bug("  UTResolveWDCB() returned %d, dirID %d\n", r.d[0], ReadMacInt32(wdcb + wdDirID)));
2057          if (r.d[0] & 0xffff)
2058 <                return r.d[0];
2058 >                return (int16)r.d[0];
2059  
2060          // Return information
2061 <        WriteMacInt16(pb + ioWDProcID, ReadMacInt32(wdcb + wdProcID));
2061 >        WriteMacInt32(pb + ioWDProcID, ReadMacInt32(wdcb + wdProcID));
2062          WriteMacInt16(pb + ioWDVRefNum, ReadMacInt16(ReadMacInt32(wdcb + wdVCBPtr) + vcbVRefNum));
2063          if (ReadMacInt32(pb + ioNamePtr))
2064 <                memcpy(Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), Mac2HostAddr(ReadMacInt32(wdcb + wdVCBPtr) + vcbVN), 28);
2064 >                Mac2Mac_memcpy(ReadMacInt32(pb + ioNamePtr), ReadMacInt32(wdcb + wdVCBPtr) + vcbVN, 28);
2065          WriteMacInt32(pb + ioWDDirID, ReadMacInt32(wdcb + wdDirID));
2066          return noErr;
2067   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines