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.15 by cebix, 1999-12-22T16:16:09Z vs.
Revision 1.33 by asvitkine, 2007-01-24T02:37:06Z

# 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-2005 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 40 | Line 40
40   #include <string.h>
41   #include <stdio.h>
42   #include <stdlib.h>
43 #include <unistd.h>
43   #include <fcntl.h>
45 #include <dirent.h>
44   #include <errno.h>
45  
46 + #ifndef WIN32
47 + #include <unistd.h>
48 + #include <dirent.h>
49 + #endif
50 +
51 + #if defined __APPLE__ && defined __MACH__
52 + #include <sys/attr.h>
53 + #endif
54 +
55   #include "cpu_emulation.h"
49 #include "macos_util.h"
56   #include "emul_op.h"
57   #include "main.h"
58   #include "disk.h"
# Line 55 | Line 61
61   #include "extfs.h"
62   #include "extfs_defs.h"
63  
64 + #ifdef WIN32
65 + # include "posix_emu.h"
66 + #endif
67 +
68   #define DEBUG 0
69   #include "debug.h"
70  
# Line 65 | Line 75 | enum {
75          fsHFSProcStub = 6,
76          fsDrvStatus = 12,                               // Drive Status record
77          fsFSD = 42,                                             // File system descriptor
78 <        fsPB = 238,                                             // IOParam (for mounting and renaming)
78 >        fsPB = 238,                                             // IOParam (for mounting and renaming), also used for temporary storage
79          fsVMI = 288,                                    // VoumeMountInfoHeader (for mounting)
80          fsParseRec = 296,                               // ParsePathRec struct
81          fsReturn = 306,                                 // Area for return data of 68k routines
# Line 101 | Line 111 | static bool ready = false;
111   static struct stat root_stat;
112  
113   // File system ID/media type
114 < const int16 MY_FSID = 'ba';
115 < const uint32 MY_MEDIA_TYPE = 'basi';
114 > const int16 MY_FSID = EMULATOR_ID_2;
115 > const uint32 MY_MEDIA_TYPE = EMULATOR_ID_4;
116  
117   // CNID of root and root's parent
118   const uint32 ROOT_ID = 2;
# Line 111 | Line 121 | const uint32 ROOT_PARENT_ID = 1;
121   // File system stack size
122   const int STACK_SIZE = 0x10000;
123  
124 + // Allocation block and clump size as reported to MacOS (these are of course
125 + // not the real values and have no meaning on the host OS)
126 + const int AL_BLK_SIZE = 0x4000;
127 + const int CLUMP_SIZE = 0x4000;
128 +
129   // Drive number of our pseudo-drive
130   static int drive_number;
131  
# Line 143 | Line 158 | struct FSItem {
158          uint32 id;                              // CNID of this file/dir
159          uint32 parent_id;               // CNID of parent file/dir
160          FSItem *parent;                 // Pointer to parent
161 <        char name[32];                  // Object name (C string)
161 >        char name[32];                  // Object name (C string) - Host OS
162 >        char guest_name[32];                    // Object name (C string) - Guest OS
163          time_t mtime;                   // Modification time for get_cat_info caching
164          int cache_dircount;             // Cached number of files in directory
165   };
# Line 154 | Line 170 | static uint32 next_cnid = fsUsrCNID;   //
170  
171  
172   /*
173 + *  Get object creation time
174 + */
175 +
176 + #if defined __APPLE__ && defined __MACH__
177 + struct crtimebuf {
178 +        unsigned long length;
179 +        struct timespec crtime;
180 + };
181 +
182 + static uint32 do_get_creation_time(const char *path)
183 + {
184 +        struct attrlist attr;
185 +        memset(&attr, 0, sizeof(attr));
186 +        attr.bitmapcount = ATTR_BIT_MAP_COUNT;
187 +        attr.commonattr = ATTR_CMN_CRTIME;
188 +
189 +        crtimebuf buf;
190 +        if (getattrlist(path, &attr, &buf, sizeof(buf), FSOPT_NOFOLLOW) < 0)
191 +                return 0;
192 +        return TimeToMacTime(buf.crtime.tv_sec);
193 + }
194 +
195 + static uint32 get_creation_time(const char *path)
196 + {
197 +        if (path == NULL)
198 +                return 0;
199 +        if (path == RootPath) {
200 +                static uint32 root_crtime = UINT_MAX;
201 +                if (root_crtime == UINT_MAX)
202 +                        root_crtime = do_get_creation_time(path);
203 +                return root_crtime;
204 +        }
205 +        return do_get_creation_time(path);
206 + }
207 + #endif
208 +
209 +
210 + /*
211   *  Find FSItem for given CNID
212   */
213  
# Line 168 | Line 222 | static FSItem *find_fsitem_by_id(uint32
222          return NULL;
223   }
224  
225 + /*
226 + *  Create FSItem with the given parameters
227 + */
228 +
229 + static FSItem *create_fsitem(const char *name, const char *guest_name, FSItem *parent)
230 + {
231 +        FSItem *p = new FSItem;
232 +        last_fs_item->next = p;
233 +        p->next = NULL;
234 +        last_fs_item = p;
235 +        p->id = next_cnid++;
236 +        p->parent_id = parent->id;
237 +        p->parent = parent;
238 +        strncpy(p->name, name, 31);
239 +        p->name[31] = 0;
240 +        strncpy(p->guest_name, guest_name, 31);
241 +        p->guest_name[31] = 0;
242 +        p->mtime = 0;
243 +        return p;
244 + }
245  
246   /*
247   *  Find FSItem for given name and parent, construct new FSItem if not found
# Line 183 | Line 257 | static FSItem *find_fsitem(const char *n
257          }
258  
259          // Not found, construct new FSItem
260 <        p = new FSItem;
187 <        last_fs_item->next = p;
188 <        p->next = NULL;
189 <        last_fs_item = p;
190 <        p->id = next_cnid++;
191 <        p->parent_id = parent->id;
192 <        p->parent = parent;
193 <        strncpy(p->name, name, 31);
194 <        p->name[31] = 0;
195 <        p->mtime = 0;
196 <        return p;
260 >        return create_fsitem(name, host_encoding_to_macroman(name), parent);
261   }
262  
263 + /*
264 + *  Find FSItem for given guest_name and parent, construct new FSItem if not found
265 + */
266 +
267 + static FSItem *find_fsitem_guest(const char *guest_name, FSItem *parent)
268 + {
269 +        FSItem *p = first_fs_item;
270 +        while (p) {
271 +                if (p->parent == parent && !strcmp(p->guest_name, guest_name))
272 +                        return p;
273 +                p = p->next;
274 +        }
275 +
276 +        // Not found, construct new FSItem
277 +        return create_fsitem(macroman_to_host_encoding(guest_name), guest_name, parent);
278 + }
279  
280   /*
281   *  Get full path (->full_path) for given FSItem
# Line 257 | Line 337 | static void cstr2pstr(char *dst, const c
337          *dst++ = strlen(src);
338          char c;
339          while ((c = *src++) != 0) {
340 +                // Note: we are converting host ':' characters to Mac '/' characters here
341 +                // '/' is not a path separator as this function is only used on object names
342                  if (c == ':')
343                          c = '/';
344                  *dst++ = c;
345          }
346   }
347  
266 // Convert pascal string to C string
267 static void pstr2cstr(char *dst, const char *src)
268 {
269        int size = *src++;
270        while (size--) {
271                char c = *src++;
272                if (c == '/')
273                        c = ':';
274                *dst++ = c;
275        }
276        *dst = 0;
277 }
278
348   // Convert string (no length byte) to C string, length given separately
349   static void strn2cstr(char *dst, const char *src, int size)
350   {
351          while (size--) {
352                  char c = *src++;
353 +                // Note: we are converting Mac '/' characters to host ':' characters here
354 +                // '/' is not a path separator as this function is only used on object names
355                  if (c == '/')
356                          c = ':';
357                  *dst++ = c;
# Line 346 | Line 417 | void ExtFSInit(void)
417          p->parent_id = 0;
418          p->parent = NULL;
419          p->name[0] = 0;
420 +        p->guest_name[0] = 0;
421  
422          // Create root FSItem
423          p = new FSItem;
# Line 356 | Line 428 | void ExtFSInit(void)
428          p->parent_id = ROOT_PARENT_ID;
429          p->parent = first_fs_item;
430          strncpy(p->name, GetString(STR_EXTFS_VOLUME_NAME), 32);
431 +        p->name[31] = 0;
432 +        strncpy(p->guest_name, host_encoding_to_macroman(p->name), 32);
433 +        p->guest_name[31] = 0;
434  
435          // Find path for root
436          if ((RootPath = PrefsFindString("extfs")) != NULL) {
# Line 404 | Line 479 | void InstallExtFS(void)
479          // FSM present?
480          r.d[0] = gestaltFSAttr;
481          Execute68kTrap(0xa1ad, &r);     // Gestalt()
482 <        D(bug("FSAttr %ld, %08lx\n", r.d[0], r.a[0]));
482 >        D(bug("FSAttr %d, %08x\n", r.d[0], r.a[0]));
483          if ((r.d[0] & 0xffff) || !(r.a[0] & (1 << gestaltHasFileSystemManager))) {
484                  printf("WARNING: No FSM present, disabling ExtFS\n");
485                  return;
# Line 413 | Line 488 | void InstallExtFS(void)
488          // Yes, version >=1.2?
489          r.d[0] = gestaltFSMVersion;
490          Execute68kTrap(0xa1ad, &r);     // Gestalt()
491 <        D(bug("FSMVersion %ld, %08lx\n", r.d[0], r.a[0]));
491 >        D(bug("FSMVersion %d, %08x\n", r.d[0], r.a[0]));
492          if ((r.d[0] & 0xffff) || (r.a[0] < 0x0120)) {
493                  printf("WARNING: FSM <1.2 found, disabling ExtFS\n");
494                  return;
# Line 683 | Line 758 | int16 ExtFSComm(uint16 message, uint32 p
758                  }
759  
760                  case ffsIDDiskMessage: {                // Check if volume is handled by our FS
761 <                        if (ReadMacInt16(paramBlock + ioVRefNum) == drive_number)
761 >                        if ((int16)ReadMacInt16(paramBlock + ioVRefNum) == drive_number)
762                                  return noErr;
763                          else
764                                  return extFSErr;
# Line 727 | Line 802 | static int16 get_current_dir(uint32 pb,
802          if (no_vol_name)
803                  WriteMacInt32(pb + ioNamePtr, name_ptr);
804          int16 status = ReadMacInt16(fs_data + fsReturn);
730        int16 more_matches = ReadMacInt16(fs_data + fsReturn + 2);
731        int16 vRefNum = ReadMacInt16(fs_data + fsReturn + 4);
732        uint32 vcb = ReadMacInt32(fs_data + fsReturn + 6);
805          D(bug("  UTDetermineVol() returned %d, status %d\n", r.d[0], status));
806 <        result = r.d[0] & 0xffff;
806 >        result = (int16)(r.d[0] & 0xffff);
807  
808          if (result == noErr) {
809                  switch (status) {
# Line 756 | Line 828 | static int16 get_current_dir(uint32 pb,
828                                          Execute68k(fs_data + fsResolveWDCB, &r);
829                                          uint32 wdcb = ReadMacInt32(fs_data + fsReturn);
830                                          D(bug("  UTResolveWDCB() returned %d, dirID %d\n", r.d[0], ReadMacInt32(wdcb + wdDirID)));
831 <                                        result = r.d[0] & 0xffff;
831 >                                        result = (int16)(r.d[0] & 0xffff);
832                                          if (result == noErr)
833                                                  current_dir = ReadMacInt32(wdcb + wdDirID);
834                                  }
# Line 772 | Line 844 | static int16 get_current_dir(uint32 pb,
844                                          r.a[0] = wdpb;
845                                          Execute68k(fs_data + fsGetDefaultVol, &r);
846                                          D(bug("  UTGetDefaultVol() returned %d, dirID %d\n", r.d[0], ReadMacInt32(wdpb + ioWDDirID)));
847 <                                        result = r.d[0] & 0xffff;
847 >                                        result = (int16)(r.d[0] & 0xffff);
848                                          if (result == noErr)
849                                                  current_dir = ReadMacInt32(wdpb + ioWDDirID);
850                                  }
# Line 798 | Line 870 | static int16 get_path_component_name(uin
870          r.a[0] = rec;
871          Execute68k(fs_data + fsGetPathComponentName, &r);
872   //      D(bug("  UTGetPathComponentName returned %d\n", r.d[0]));
873 <        return r.d[0] & 0xffff;
873 >        return (int16)(r.d[0] & 0xffff);
874   }
875  
876  
# Line 834 | Line 906 | static int16 get_item_and_path(uint32 pb
906          r.a[1] = ReadMacInt32(parseRec + ppNamePtr);
907          Execute68k(fs_data + fsParsePathname, &r);
908          D(bug("  UTParsePathname() returned %d, startOffset %d\n", r.d[0], ReadMacInt16(parseRec + ppStartOffset)));
909 <        result = r.d[0] & 0xffff;
909 >        result = (int16)(r.d[0] & 0xffff);
910          if (result == noErr) {
911  
912                  // Check for leading delimiter of the partial pathname
# Line 869 | Line 941 | static int16 get_item_and_path(uint32 pb
941                                                  char name[32];
942                                                  strn2cstr(name, (char *)Mac2HostAddr(ReadMacInt32(parseRec + ppNamePtr)) + ReadMacInt16(parseRec + ppStartOffset) + 1, ReadMacInt16(parseRec + ppComponentLength));
943                                                  D(bug("  entering %s\n", name));
944 <                                                p = find_fsitem(name, p);
944 >                                                p = find_fsitem_guest(name, p);
945                                                  current_dir = p->id;
946  
947                                                  // startOffset = start of next component
# Line 892 | Line 964 | static int16 get_item_and_path(uint32 pb
964                                          char name[32];
965                                          strn2cstr(name, (char *)Mac2HostAddr(ReadMacInt32(parseRec + ppNamePtr)) + ReadMacInt16(parseRec + ppStartOffset) + 1, ReadMacInt16(parseRec + ppComponentLength));
966                                          D(bug("  object is %s\n", name));
967 <                                        item = find_fsitem(name, p);
967 >                                        item = find_fsitem_guest(name, p);
968                                  }
969                          }
970                  }
# Line 947 | Line 1019 | static uint32 find_fcb(int16 refNum)
1019   static int16 fs_mount_vol(uint32 pb)
1020   {
1021          D(bug(" fs_mount_vol(%08lx), vRefNum %d\n", pb, ReadMacInt16(pb + ioVRefNum)));
1022 <        if (ReadMacInt16(pb + ioVRefNum) == drive_number)
1022 >        if ((int16)ReadMacInt16(pb + ioVRefNum) == drive_number)
1023                  return noErr;
1024          else
1025                  return extFSErr;
# Line 964 | Line 1036 | static int16 fs_volume_mount(uint32 pb)
1036          r.a[0] = fs_data + fsReturn;
1037          r.a[1] = fs_data + fsReturn + 2;
1038          Execute68k(fs_data + fsAllocateVCB, &r);
1039 + #if DEBUG
1040          uint16 sysVCBLength = ReadMacInt16(fs_data + fsReturn);
1041 + #endif
1042          uint32 vcb = ReadMacInt32(fs_data + fsReturn + 2);
1043          D(bug("  UTAllocateVCB() returned %d, vcb %08lx, size %d\n", r.d[0], vcb, sysVCBLength));
1044          if (r.d[0] & 0xffff)
1045 <                return r.d[0];
1045 >                return (int16)r.d[0];
1046  
1047          // Init VCB
1048          WriteMacInt16(vcb + vcbSigWord, 0x4244);
1049 < #ifdef __BEOS__
1050 <        WriteMacInt32(vcb + vcbCrDate, root_stat.st_crtime + TIME_OFFSET);
1049 > #if defined(__BEOS__) || defined(WIN32)
1050 >        WriteMacInt32(vcb + vcbCrDate, TimeToMacTime(root_stat.st_crtime));
1051 > #elif defined __APPLE__ && defined __MACH__
1052 >        WriteMacInt32(vcb + vcbCrDate, get_creation_time(RootPath));
1053   #else
1054          WriteMacInt32(vcb + vcbCrDate, 0);
1055   #endif
1056 <        WriteMacInt32(vcb + vcbLsMod, root_stat.st_mtime + TIME_OFFSET);
1056 >        WriteMacInt32(vcb + vcbLsMod, TimeToMacTime(root_stat.st_mtime));
1057          WriteMacInt32(vcb + vcbVolBkUp, 0);
1058          WriteMacInt16(vcb + vcbNmFls, 1);                       //!!
1059          WriteMacInt16(vcb + vcbNmRtDirs, 1);            //!!
1060          WriteMacInt16(vcb + vcbNmAlBlks, 0xffff);       //!!
1061 <        WriteMacInt32(vcb + vcbAlBlkSiz, 1024);
1062 <        WriteMacInt32(vcb + vcbClpSiz, 1024);
1061 >        WriteMacInt32(vcb + vcbAlBlkSiz, AL_BLK_SIZE);
1062 >        WriteMacInt32(vcb + vcbClpSiz, CLUMP_SIZE);
1063          WriteMacInt32(vcb + vcbNxtCNID, next_cnid);
1064          WriteMacInt16(vcb + vcbFreeBks, 0xffff);        //!!
1065          Host2Mac_memcpy(vcb + vcbVN, VOLUME_NAME, 28);
# Line 997 | Line 1073 | static int16 fs_volume_mount(uint32 pb)
1073          r.a[0] = fs_data + fsReturn;
1074          r.a[1] = vcb;
1075          Execute68k(fs_data + fsAddNewVCB, &r);
1076 <        int16 vRefNum = ReadMacInt32(fs_data + fsReturn);
1076 >        int16 vRefNum = (int16)ReadMacInt32(fs_data + fsReturn);
1077          D(bug("  UTAddNewVCB() returned %d, vRefNum %d\n", r.d[0], vRefNum));
1078          if (r.d[0] & 0xffff)
1079 <                return r.d[0];
1079 >                return (int16)r.d[0];
1080  
1081          // Post diskInsertEvent
1082          D(bug("  posting diskInsertEvent\n"));
# Line 1024 | Line 1100 | static int16 fs_unmount_vol(uint32 vcb)
1100          r.a[0] = vcb;
1101          Execute68k(fs_data + fsDisposeVCB, &r);
1102          D(bug("  UTDisposeVCB() returned %d\n", r.d[0]));
1103 <        return r.d[0];
1103 >        return (int16)r.d[0];
1104   }
1105  
1106   // Get information about a volume (HVolumeParam)
# Line 1035 | Line 1111 | static int16 fs_get_vol_info(uint32 pb,
1111          // Fill in struct
1112          if (ReadMacInt32(pb + ioNamePtr))
1113                  pstrcpy((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), VOLUME_NAME);
1114 < #ifdef __BEOS__
1115 <        WriteMacInt32(pb + ioVCrDate, root_stat.st_crtime + TIME_OFFSET);
1114 > #if defined(__BEOS__) || defined(WIN32)
1115 >        WriteMacInt32(pb + ioVCrDate, TimeToMacTime(root_stat.st_crtime));
1116 > #elif defined __APPLE__ && defined __MACH__
1117 >        WriteMacInt32(pb + ioVCrDate, get_creation_time(RootPath));
1118   #else
1119          WriteMacInt32(pb + ioVCrDate, 0);
1120   #endif
1121 <        WriteMacInt32(pb + ioVLsMod, root_stat.st_mtime + TIME_OFFSET);
1121 >        WriteMacInt32(pb + ioVLsMod, TimeToMacTime(root_stat.st_mtime));
1122          WriteMacInt16(pb + ioVAtrb, 0);
1123          WriteMacInt16(pb + ioVNmFls, 1);                        //!!
1124          WriteMacInt16(pb + ioVBitMap, 0);
1125          WriteMacInt16(pb + ioAllocPtr, 0);
1126          WriteMacInt16(pb + ioVNmAlBlks, 0xffff);        //!!
1127 <        WriteMacInt32(pb + ioVAlBlkSiz, 1024);
1128 <        WriteMacInt32(pb + ioVClpSiz, 1024);
1127 >        WriteMacInt32(pb + ioVAlBlkSiz, AL_BLK_SIZE);
1128 >        WriteMacInt32(pb + ioVClpSiz, CLUMP_SIZE);
1129          WriteMacInt16(pb + ioAlBlSt, 0);
1130          WriteMacInt32(pb + ioVNxtCNID, next_cnid);
1131          WriteMacInt16(pb + ioVFrBlk, 0xffff);           //!!
# Line 1105 | Line 1183 | static int16 fs_get_vol(uint32 pb)
1183          r.a[0] = pb;
1184          Execute68k(fs_data + fsGetDefaultVol, &r);
1185          D(bug("  UTGetDefaultVol() returned %d\n", r.d[0]));
1186 <        return r.d[0];
1186 >        return (int16)r.d[0];
1187   }
1188  
1189   // Set default volume (WDParam)
# Line 1161 | Line 1239 | static int16 fs_set_vol(uint32 pb, bool
1239          r.d[2] = refNum;
1240          Execute68k(fs_data + fsSetDefaultVol, &r);
1241          D(bug("  UTSetDefaultVol() returned %d\n", r.d[0]));
1242 <        return r.d[0];
1242 >        return (int16)r.d[0];
1243   }
1244  
1245   // Query file attributes (HFileParam)
# Line 1222 | Line 1300 | read_next_de:
1300  
1301          // Fill in struct from fs_item and stats
1302          if (ReadMacInt32(pb + ioNamePtr))
1303 <                cstr2pstr((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), fs_item->name);
1303 >                cstr2pstr((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), fs_item->guest_name);
1304          WriteMacInt16(pb + ioFRefNum, 0);
1305          WriteMacInt8(pb + ioFlAttrib, access(full_path, W_OK) == 0 ? 0 : faLocked);
1306          WriteMacInt32(pb + ioDirID, fs_item->id);
1307  
1308 < #ifdef __BEOS__
1309 <        WriteMacInt32(pb + ioFlCrDat, st.st_crtime + TIME_OFFSET);
1308 > #if defined(__BEOS__) || defined(WIN32)
1309 >        WriteMacInt32(pb + ioFlCrDat, TimeToMacTime(st.st_crtime));
1310 > #elif defined __APPLE__ && defined __MACH__
1311 >        WriteMacInt32(pb + ioFlCrDat, get_creation_time(full_path));
1312   #else
1313          WriteMacInt32(pb + ioFlCrDat, 0);
1314   #endif
1315 <        WriteMacInt32(pb + ioFlMdDat, st.st_mtime + TIME_OFFSET);
1315 >        WriteMacInt32(pb + ioFlMdDat, TimeToMacTime(st.st_mtime));
1316  
1317 <        Mac_memset(pb + ioFlFndrInfo, 0, SIZEOF_FInfo);
1238 <        uint32 type, creator;   // pb may point to kernel space, but stack is switched
1239 <        get_finder_type(full_path, type, creator);
1240 <        WriteMacInt32(pb + ioFlFndrInfo + fdType, type);
1241 <        WriteMacInt32(pb + ioFlFndrInfo + fdCreator, creator);
1242 <        uint16 fflags;
1243 <        get_finder_flags(full_path, fflags);
1244 <        WriteMacInt16(pb + ioFlFndrInfo + fdFlags, fflags);
1317 >        get_finfo(full_path, pb + ioFlFndrInfo, hfs ? pb + ioFlXFndrInfo : 0, false);
1318  
1319          WriteMacInt16(pb + ioFlStBlk, 0);
1320          WriteMacInt32(pb + ioFlLgLen, st.st_size);
1321 <        WriteMacInt32(pb + ioFlPyLen, (st.st_size + 1023) & ~1023);
1321 >        WriteMacInt32(pb + ioFlPyLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1322          WriteMacInt16(pb + ioFlRStBlk, 0);
1323          uint32 rf_size = get_rfork_size(full_path);
1324          WriteMacInt32(pb + ioFlRLgLen, rf_size);
1325 <        WriteMacInt32(pb + ioFlRPyLen, (rf_size + 1023) & ~1023);
1325 >        WriteMacInt32(pb + ioFlRPyLen, (rf_size | (AL_BLK_SIZE - 1)) + 1);
1326  
1327          if (hfs) {
1328                  WriteMacInt32(pb + ioFlBkDat, 0);
1256                Mac_memset(pb + ioFlXFndrInfo, 0, SIZEOF_FXInfo);
1329                  WriteMacInt32(pb + ioFlParID, fs_item->parent_id);
1330                  WriteMacInt32(pb + ioFlClpSiz, 0);
1331          }
# Line 1278 | Line 1350 | static int16 fs_set_file_info(uint32 pb,
1350          if (S_ISDIR(st.st_mode))
1351                  return fnfErr;
1352  
1353 <        // Set attributes
1354 <        set_finder_type(full_path, ReadMacInt32(pb + ioFlFndrInfo + fdType), ReadMacInt32(pb + ioFlFndrInfo + fdCreator));
1355 <        set_finder_flags(full_path, ReadMacInt16(pb + ioFlFndrInfo + fdFlags));
1353 >        // Set Finder info
1354 >        set_finfo(full_path, pb + ioFlFndrInfo, hfs ? pb + ioFlXFndrInfo : 0, false);
1355 >
1356          //!! times
1357          return noErr;
1358   }
# Line 1351 | Line 1423 | read_next_de:
1423  
1424          // Fill in struct from fs_item and stats
1425          if (ReadMacInt32(pb + ioNamePtr))
1426 <                cstr2pstr((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), fs_item->name);
1426 >                cstr2pstr((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), fs_item->guest_name);
1427          WriteMacInt16(pb + ioFRefNum, 0);
1428          WriteMacInt8(pb + ioFlAttrib, (S_ISDIR(st.st_mode) ? faIsDir : 0) | (access(full_path, W_OK) == 0 ? 0 : faLocked));
1429          WriteMacInt8(pb + ioACUser, 0);
1430          WriteMacInt32(pb + ioDirID, fs_item->id);
1431          WriteMacInt32(pb + ioFlParID, fs_item->parent_id);
1432 < #ifdef __BEOS__
1433 <        WriteMacInt32(pb + ioFlCrDat, st.st_crtime + TIME_OFFSET);
1432 > #if defined(__BEOS__) || defined(WIN32)
1433 >        WriteMacInt32(pb + ioFlCrDat, TimeToMacTime(st.st_crtime));
1434 > #elif defined __APPLE__ && defined __MACH__
1435 >        WriteMacInt32(pb + ioFlCrDat, get_creation_time(full_path));
1436   #else
1437          WriteMacInt32(pb + ioFlCrDat, 0);
1438   #endif
# Line 1368 | Line 1442 | read_next_de:
1442                  fs_item->mtime = mtime;
1443                  cached = false;
1444          }
1445 <        WriteMacInt32(pb + ioFlMdDat, mtime + TIME_OFFSET);
1445 >        WriteMacInt32(pb + ioFlMdDat, TimeToMacTime(mtime));
1446          WriteMacInt32(pb + ioFlBkDat, 0);
1447 +
1448 +        get_finfo(full_path, pb + ioFlFndrInfo, pb + ioFlXFndrInfo, S_ISDIR(st.st_mode));
1449 +
1450          if (S_ISDIR(st.st_mode)) {
1374                Mac_memset(pb + ioDrUsrWds, 0, SIZEOF_DInfo);
1375                Mac_memset(pb + ioDrFndrInfo, 0, SIZEOF_DXInfo);
1376                uint16 fflags;  // pb may point to kernel space, but stack is switched
1377                get_finder_flags(full_path, fflags);
1378                WriteMacInt16(pb + ioDrUsrWds + frFlags, fflags);
1451  
1452                  // Determine number of files in directory (cached)
1453                  int count;
# Line 1400 | Line 1472 | read_next_de:
1472                  }
1473                  WriteMacInt16(pb + ioDrNmFls, count);
1474          } else {
1403                Mac_memset(pb + ioFlFndrInfo, 0, SIZEOF_FInfo);
1404                Mac_memset(pb + ioFlXFndrInfo, 0, SIZEOF_FXInfo);
1405                uint32 type, creator;   // pb may point to kernel space, but stack is switched
1406                get_finder_type(full_path, type, creator);
1407                WriteMacInt32(pb + ioFlFndrInfo + fdType, type);
1408                WriteMacInt32(pb + ioFlFndrInfo + fdCreator, creator);
1409                uint16 fflags;
1410                get_finder_flags(full_path, fflags);
1411                WriteMacInt16(pb + ioFlFndrInfo + fdFlags, fflags);
1475                  WriteMacInt16(pb + ioFlStBlk, 0);
1476                  WriteMacInt32(pb + ioFlLgLen, st.st_size);
1477 <                WriteMacInt32(pb + ioFlPyLen, (st.st_size + 1023) & ~1023);
1477 >                WriteMacInt32(pb + ioFlPyLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1478                  WriteMacInt16(pb + ioFlRStBlk, 0);
1479                  uint32 rf_size = get_rfork_size(full_path);
1480                  WriteMacInt32(pb + ioFlRLgLen, rf_size);
1481 <                WriteMacInt32(pb + ioFlRPyLen, (rf_size + 1023) & ~1023);
1481 >                WriteMacInt32(pb + ioFlRPyLen, (rf_size | (AL_BLK_SIZE - 1)) + 1);
1482                  WriteMacInt32(pb + ioFlClpSiz, 0);
1483          }
1484          return noErr;
# Line 1437 | Line 1500 | static int16 fs_set_cat_info(uint32 pb)
1500          if (stat(full_path, &st) < 0)
1501                  return errno2oserr();
1502  
1503 <        // Set attributes
1504 <        if (S_ISDIR(st.st_mode))
1505 <                set_finder_flags(full_path, ReadMacInt16(pb + ioDrUsrWds + frFlags));
1443 <        else {
1444 <                set_finder_type(full_path, ReadMacInt32(pb + ioFlFndrInfo + fdType), ReadMacInt32(pb + ioFlFndrInfo + fdCreator));
1445 <                set_finder_flags(full_path, ReadMacInt16(pb + ioFlFndrInfo + fdFlags));
1446 <        }
1503 >        // Set Finder info
1504 >        set_finfo(full_path, pb + ioFlFndrInfo, pb + ioFlXFndrInfo, S_ISDIR(st.st_mode));
1505 >
1506          //!! times
1507          return noErr;
1508   }
# Line 1490 | Line 1549 | static int16 fs_open(uint32 pb, uint32 d
1549                  if (access(full_path, F_OK))
1550                          return fnfErr;
1551                  fd = open_rfork(full_path, flag);
1552 <                if (fd > 0) {
1552 >                if (fd >= 0) {
1553                          if (fstat(fd, &st) < 0) {
1554                                  close(fd);
1555                                  return errno2oserr();
# Line 1518 | Line 1577 | static int16 fs_open(uint32 pb, uint32 d
1577          D(bug("  UTAllocateFCB() returned %d, fRefNum %d, fcb %08lx\n", r.d[0], ReadMacInt16(pb + ioRefNum), fcb));
1578          if (r.d[0] & 0xffff) {
1579                  close(fd);
1580 <                return r.d[0];
1580 >                return (int16)r.d[0];
1581          }
1582  
1583          // Initialize FCB, fd is stored in fcbCatPos
1584          WriteMacInt32(fcb + fcbFlNm, fs_item->id);
1585          WriteMacInt8(fcb + fcbFlags, ((flag == O_WRONLY || flag == O_RDWR) ? fcbWriteMask : 0) | (resource_fork ? fcbResourceMask : 0) | (write_ok ? 0 : fcbFileLockedMask));
1586          WriteMacInt32(fcb + fcbEOF, st.st_size);
1587 <        WriteMacInt32(fcb + fcbPLen, (st.st_size + 1023) & ~1023);
1587 >        WriteMacInt32(fcb + fcbPLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1588          WriteMacInt32(fcb + fcbCrPs, 0);
1589          WriteMacInt32(fcb + fcbVPtr, vcb);
1590 <        WriteMacInt32(fcb + fcbClmpSize, 1024);
1591 <        uint32 type, creator;   // BeOS: fcb may point to kernel space, but stack is switched
1592 <        get_finder_type(full_path, type, creator);
1593 <        WriteMacInt32(fcb + fcbFType, type);
1590 >        WriteMacInt32(fcb + fcbClmpSize, CLUMP_SIZE);
1591 >
1592 >        get_finfo(full_path, fs_data + fsPB, 0, false);
1593 >        WriteMacInt32(fcb + fcbFType, ReadMacInt32(fs_data + fsPB + fdType));
1594 >
1595          WriteMacInt32(fcb + fcbCatPos, fd);
1596          WriteMacInt32(fcb + fcbDirID, fs_item->parent_id);
1597 <        cstr2pstr((char *)Mac2HostAddr(fcb + fcbCName), fs_item->name);
1597 >        cstr2pstr((char *)Mac2HostAddr(fcb + fcbCName), fs_item->guest_name);
1598          return noErr;
1599   }
1600  
# Line 1568 | Line 1628 | static int16 fs_close(uint32 pb)
1628          r.d[0] = ReadMacInt16(pb + ioRefNum);
1629          Execute68k(fs_data + fsReleaseFCB, &r);
1630          D(bug("  UTReleaseFCB() returned %d\n", r.d[0]));
1631 <        return r.d[0];
1631 >        return (int16)r.d[0];
1632   }
1633  
1634   // Query information about FCB (FCBPBRec)
# Line 1587 | Line 1647 | static int16 fs_get_fcb_info(uint32 pb,
1647  
1648                  // Find FCB by index
1649                  WriteMacInt16(pb + ioRefNum, 0);
1650 <                for (int i=0; i<ReadMacInt16(pb + ioFCBIndx); i++) {
1650 >                for (int i=0; i<(int)ReadMacInt16(pb + ioFCBIndx); i++) {
1651                          D(bug("  indexing FCBs\n"));
1652                          r.a[0] = vcb;
1653                          r.a[1] = pb + ioRefNum;
# Line 1596 | Line 1656 | static int16 fs_get_fcb_info(uint32 pb,
1656                          fcb = ReadMacInt32(fs_data + fsReturn);
1657                          D(bug("  UTIndexFCB() returned %d, fcb %p\n", r.d[0], fcb));
1658                          if (r.d[0] & 0xffff)
1659 <                                return r.d[0];
1659 >                                return (int16)r.d[0];
1660                  }
1661          }
1662          if (fcb == 0)
# Line 1644 | Line 1704 | static int16 fs_get_eof(uint32 pb)
1704  
1705          // Adjust FCBs
1706          WriteMacInt32(fcb + fcbEOF, st.st_size);
1707 <        WriteMacInt32(fcb + fcbPLen, (st.st_size + 1023) & ~1023);
1707 >        WriteMacInt32(fcb + fcbPLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1708          WriteMacInt32(pb + ioMisc, st.st_size);
1709          D(bug("  adjusting FCBs\n"));
1710          r.d[0] = ReadMacInt16(pb + ioRefNum);
# Line 1679 | Line 1739 | static int16 fs_set_eof(uint32 pb)
1739  
1740          // Adjust FCBs
1741          WriteMacInt32(fcb + fcbEOF, size);
1742 <        WriteMacInt32(fcb + fcbPLen, (size + 1023) & ~1023);
1742 >        WriteMacInt32(fcb + fcbPLen, (size | (AL_BLK_SIZE - 1)) + 1);
1743          D(bug("  adjusting FCBs\n"));
1744          r.d[0] = ReadMacInt16(pb + ioRefNum);
1745          Execute68k(fs_data + fsAdjustEOF, &r);
# Line 1764 | Line 1824 | static int16 fs_read(uint32 pb)
1824   {
1825          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)));
1826  
1827 +        // Check parameters
1828 +        if ((int32)ReadMacInt32(pb + ioReqCount) < 0)
1829 +                return paramErr;
1830 +
1831          // Find FCB and fd for file
1832          uint32 fcb = find_fcb(ReadMacInt16(pb + ioRefNum));
1833          if (fcb == 0)
# Line 1802 | Line 1866 | static int16 fs_read(uint32 pb)
1866          uint32 pos = lseek(fd, 0, SEEK_CUR);
1867          WriteMacInt32(fcb + fcbCrPs, pos);
1868          WriteMacInt32(pb + ioPosOffset, pos);
1869 <        if (actual != ReadMacInt32(pb + ioReqCount))
1869 >        if (actual != (ssize_t)ReadMacInt32(pb + ioReqCount))
1870                  return actual < 0 ? read_err : eofErr;
1871          else
1872                  return noErr;
# Line 1813 | Line 1877 | static int16 fs_write(uint32 pb)
1877   {
1878          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)));
1879  
1880 +        // Check parameters
1881 +        if ((int32)ReadMacInt32(pb + ioReqCount) < 0)
1882 +                return paramErr;
1883 +
1884          // Find FCB and fd for file
1885          uint32 fcb = find_fcb(ReadMacInt16(pb + ioRefNum));
1886          if (fcb == 0)
# Line 1851 | Line 1919 | static int16 fs_write(uint32 pb)
1919          uint32 pos = lseek(fd, 0, SEEK_CUR);
1920          WriteMacInt32(fcb + fcbCrPs, pos);
1921          WriteMacInt32(pb + ioPosOffset, pos);
1922 <        if (actual != ReadMacInt32(pb + ioReqCount))
1922 >        if (actual != (ssize_t)ReadMacInt32(pb + ioReqCount))
1923                  return write_err;
1924          else
1925                  return noErr;
# Line 2023 | Line 2091 | static int16 fs_open_wd(uint32 pb)
2091          r.a[0] = pb;
2092          Execute68k(fs_data + fsAllocateWDCB, &r);
2093          D(bug("  UTAllocateWDCB returned %d, refNum is %d\n", r.d[0], ReadMacInt16(pb + ioVRefNum)));
2094 <        return r.d[0];
2094 >        return (int16)r.d[0];
2095   }
2096  
2097   // Close working directory (WDParam)
# Line 2037 | Line 2105 | static int16 fs_close_wd(uint32 pb)
2105          r.d[0] = ReadMacInt16(pb + ioVRefNum);
2106          Execute68k(fs_data + fsReleaseWDCB, &r);
2107          D(bug("  UTReleaseWDCB returned %d\n", r.d[0]));
2108 <        return r.d[0];
2108 >        return (int16)r.d[0];
2109   }
2110  
2111   // Query information about working directory (WDParam)
# Line 2066 | Line 2134 | static int16 fs_get_wd_info(uint32 pb, u
2134          uint32 wdcb = ReadMacInt32(fs_data + fsReturn);
2135          D(bug("  UTResolveWDCB() returned %d, dirID %d\n", r.d[0], ReadMacInt32(wdcb + wdDirID)));
2136          if (r.d[0] & 0xffff)
2137 <                return r.d[0];
2137 >                return (int16)r.d[0];
2138  
2139          // Return information
2140          WriteMacInt32(pb + ioWDProcID, ReadMacInt32(wdcb + wdProcID));

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines