65 |
|
fsHFSProcStub = 6, |
66 |
|
fsDrvStatus = 12, // Drive Status record |
67 |
|
fsFSD = 42, // File system descriptor |
68 |
< |
fsPB = 238, // IOParam (for mounting) |
68 |
> |
fsPB = 238, // IOParam (for mounting and renaming) |
69 |
|
fsVMI = 288, // VoumeMountInfoHeader (for mounting) |
70 |
|
fsParseRec = 296, // ParsePathRec struct |
71 |
|
fsReturn = 306, // Area for return data of 68k routines |
72 |
|
fsAllocateVCB = 562, // UTAllocateVCB(uint16 *sysVCBLength{a0}, uint32 *vcb{a1}) |
73 |
|
fsAddNewVCB = 578, // UTAddNewVCB(int drive_number{d0}, int16 *vRefNum{a1}, uint32 vcb{a1}) |
74 |
|
fsDetermineVol = 594, // UTDetermineVol(uint32 pb{a0}, int16 *status{a1}, int16 *more_matches{a2}, int16 *vRefNum{a3}, uint32 *vcb{a4}) |
75 |
< |
fsResolveWDCB = 614, // UTResolveWDCB(int16 vRefNum{d0}, uint32 *wdcb{a0}) |
75 |
> |
fsResolveWDCB = 614, // UTResolveWDCB(uint32 procID{d0}, int16 index{d1}, int16 vRefNum{d0}, uint32 *wdcb{a0}) |
76 |
|
fsGetDefaultVol = 632, // UTGetDefaultVol(uint32 wdpb{a0}) |
77 |
|
fsGetPathComponentName = 644, // UTGetPathComponentName(uint32 rec{a0}) |
78 |
|
fsParsePathname = 656, // UTParsePathname(uint32 *start{a0}, uint32 name{a1}) |
201 |
|
* Get full path (->full_path) for given FSItem |
202 |
|
*/ |
203 |
|
|
204 |
– |
const int MAX_PATH_LENGTH = 1024; |
204 |
|
static char full_path[MAX_PATH_LENGTH]; |
205 |
|
|
206 |
|
static void add_path_comp(const char *s) |
207 |
|
{ |
208 |
< |
add_path_component(full_path, s, MAX_PATH_LENGTH); |
208 |
> |
add_path_component(full_path, s); |
209 |
|
} |
210 |
|
|
211 |
|
static void get_path_for_fsitem(FSItem *p) |
212 |
|
{ |
213 |
< |
if (p->id == ROOT_ID) { |
213 |
> |
if (p->id == ROOT_PARENT_ID) { |
214 |
> |
full_path[0] = 0; |
215 |
> |
} else if (p->id == ROOT_ID) { |
216 |
|
strncpy(full_path, RootPath, MAX_PATH_LENGTH-1); |
217 |
|
full_path[MAX_PATH_LENGTH-1] = 0; |
218 |
|
} else { |
462 |
|
if (p - fs_data != fsResolveWDCB) |
463 |
|
goto fsdat_error; |
464 |
|
WriteMacInt16(p, 0x4267); p+= 2; // clr.w -(sp) |
465 |
< |
WriteMacInt16(p, 0x42a7); p+= 2; // clr.l -(sp) |
466 |
< |
WriteMacInt16(p, 0x4267); p+= 2; // clr.w -(sp) |
467 |
< |
WriteMacInt16(p, 0x3f00); p+= 2; // move.w d0,-(sp) |
465 |
> |
WriteMacInt16(p, 0x2f00); p+= 2; // move.l d0,-(sp) |
466 |
> |
WriteMacInt16(p, 0x3f01); p+= 2; // move.w d1,-(sp) |
467 |
> |
WriteMacInt16(p, 0x3f02); p+= 2; // move.w d2,-(sp) |
468 |
|
WriteMacInt16(p, 0x2f08); p+= 2; // move.l a0,-(sp) |
469 |
|
WriteMacInt16(p, 0x700e); p+= 2; // UTResolveWDCB |
470 |
|
WriteMacInt16(p, 0xa824); p+= 2; // FSMgr |
604 |
|
WriteMacInt16(fs_data + fsFSD + fsdLength, SIZEOF_FSDRec); |
605 |
|
WriteMacInt16(fs_data + fsFSD + fsdVersion, fsdVersion1); |
606 |
|
WriteMacInt16(fs_data + fsFSD + fileSystemFSID, MY_FSID); |
607 |
< |
memcpy(Mac2HostAddr(fs_data + fsFSD + fileSystemName), FS_NAME, 32); |
607 |
> |
Host2Mac_memcpy(fs_data + fsFSD + fileSystemName, FS_NAME, 32); |
608 |
|
WriteMacInt32(fs_data + fsFSD + fileSystemCommProc, fs_data + fsCommProcStub); |
609 |
|
WriteMacInt32(fs_data + fsFSD + fsdHFSCI + compInterfProc, fs_data + fsHFSProcStub); |
610 |
|
WriteMacInt32(fs_data + fsFSD + fsdHFSCI + stackTop, fs_stack + STACK_SIZE); |
658 |
|
|
659 |
|
case ffsGetIconMessage: { // Get disk/drive icon |
660 |
|
if (ReadMacInt8(paramBlock + iconType) == kLargeIcon && ReadMacInt32(paramBlock + requestSize) >= sizeof(ExtFSIcon)) { |
661 |
< |
memcpy(Mac2HostAddr(ReadMacInt32(paramBlock + iconBufferPtr)), ExtFSIcon, sizeof(ExtFSIcon)); |
661 |
> |
Host2Mac_memcpy(ReadMacInt32(paramBlock + iconBufferPtr), ExtFSIcon, sizeof(ExtFSIcon)); |
662 |
|
WriteMacInt32(paramBlock + actualSize, sizeof(ExtFSIcon)); |
663 |
|
return noErr; |
664 |
|
} else |
732 |
|
current_dir = dirID; |
733 |
|
else { |
734 |
|
D(bug(" resolving WDCB\n")); |
735 |
< |
r.d[0] = ReadMacInt16(pb + ioVRefNum); |
735 |
> |
r.d[0] = 0; |
736 |
> |
r.d[1] = 0; |
737 |
> |
r.d[2] = ReadMacInt16(pb + ioVRefNum); |
738 |
|
r.a[0] = fs_data + fsReturn; |
739 |
|
Execute68k(fs_data + fsResolveWDCB, &r); |
740 |
|
uint32 wdcb = ReadMacInt32(fs_data + fsReturn); |
969 |
|
WriteMacInt32(vcb + vcbClpSiz, 1024); |
970 |
|
WriteMacInt32(vcb + vcbNxtCNID, next_cnid); |
971 |
|
WriteMacInt16(vcb + vcbFreeBks, 0xffff); //!! |
972 |
< |
memcpy(Mac2HostAddr(vcb + vcbVN), VOLUME_NAME, 28); |
972 |
> |
Host2Mac_memcpy(vcb + vcbVN, VOLUME_NAME, 28); |
973 |
|
WriteMacInt16(vcb + vcbFSID, MY_FSID); |
974 |
|
WriteMacInt32(vcb + vcbFilCnt, 1); //!! |
975 |
|
WriteMacInt32(vcb + vcbDirCnt, 1); //!! |
1043 |
|
WriteMacInt32(pb + ioVWrCnt, 0); |
1044 |
|
WriteMacInt32(pb + ioVFilCnt, 1); //!! |
1045 |
|
WriteMacInt32(pb + ioVDirCnt, 1); //!! |
1046 |
< |
memset(Mac2HostAddr(pb + ioVFndrInfo), 0, 32); |
1046 |
> |
Mac_memset(pb + ioVFndrInfo, 0, 32); |
1047 |
|
} |
1048 |
|
return noErr; |
1049 |
|
} |
1073 |
|
uint32 actual = ReadMacInt32(pb + ioReqCount); |
1074 |
|
if (actual > sizeof(vol)) |
1075 |
|
actual = sizeof(vol); |
1076 |
< |
memcpy(Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), vol, actual); |
1076 |
> |
Host2Mac_memcpy(ReadMacInt32(pb + ioBuffer), vol, actual); |
1077 |
|
WriteMacInt32(pb + ioActCount, actual); |
1078 |
|
return noErr; |
1079 |
|
} |
1154 |
|
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)); |
1155 |
|
|
1156 |
|
FSItem *fs_item; |
1157 |
< |
int16 dir_index = (int16)ReadMacInt16(pb + ioFDirIndex); |
1157 |
> |
int16 dir_index = ReadMacInt16(pb + ioFDirIndex); |
1158 |
|
if (dir_index <= 0) { // Query item specified by ioDirID and ioNamePtr |
1159 |
|
|
1160 |
|
// Find FSItem for given file |
1187 |
|
return fnfErr; |
1188 |
|
} |
1189 |
|
if (de->d_name[0] == '.') |
1190 |
< |
goto read_next_de; // Suppress name beginning with '.' (MacOS could interpret these as driver names) |
1190 |
> |
goto read_next_de; // Suppress names beginning with '.' (MacOS could interpret these as driver names) |
1191 |
|
//!! suppress directories |
1192 |
|
} |
1193 |
|
add_path_comp(de->d_name); |
1218 |
|
#endif |
1219 |
|
WriteMacInt32(pb + ioFlMdDat, st.st_mtime + TIME_OFFSET); |
1220 |
|
|
1221 |
< |
memset(Mac2HostAddr(pb + ioFlFndrInfo), 0, SIZEOF_FInfo); |
1221 |
> |
Mac_memset(pb + ioFlFndrInfo, 0, SIZEOF_FInfo); |
1222 |
|
uint32 type, creator; // pb may point to kernel space, but stack is switched |
1223 |
|
get_finder_type(full_path, type, creator); |
1224 |
|
WriteMacInt32(pb + ioFlFndrInfo + fdType, type); |
1237 |
|
|
1238 |
|
if (hfs) { |
1239 |
|
WriteMacInt32(pb + ioFlBkDat, 0); |
1240 |
< |
memset(Mac2HostAddr(pb + ioFlXFndrInfo), 0, SIZEOF_FXInfo); |
1240 |
> |
Mac_memset(pb + ioFlXFndrInfo, 0, SIZEOF_FXInfo); |
1241 |
|
WriteMacInt32(pb + ioFlParID, fs_item->parent_id); |
1242 |
|
WriteMacInt32(pb + ioFlClpSiz, 0); |
1243 |
|
} |
1275 |
|
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))); |
1276 |
|
|
1277 |
|
FSItem *fs_item; |
1278 |
< |
int16 dir_index = (int16)ReadMacInt16(pb + ioFDirIndex); |
1278 |
> |
int16 dir_index = ReadMacInt16(pb + ioFDirIndex); |
1279 |
|
if (dir_index < 0) { // Query directory specified by ioDirID |
1280 |
|
|
1281 |
|
// Find FSItem for directory |
1316 |
|
return fnfErr; |
1317 |
|
} |
1318 |
|
if (de->d_name[0] == '.') |
1319 |
< |
goto read_next_de; // Suppress name beginning with '.' (MacOS could interpret these as driver names) |
1319 |
> |
goto read_next_de; // Suppress names beginning with '.' (MacOS could interpret these as driver names) |
1320 |
|
} |
1321 |
|
add_path_comp(de->d_name); |
1322 |
|
|
1352 |
|
fs_item->mtime = mtime; |
1353 |
|
cached = false; |
1354 |
|
} |
1355 |
< |
WriteMacInt32(pb + ioFlMdDat, mtime); |
1355 |
> |
WriteMacInt32(pb + ioFlMdDat, mtime + TIME_OFFSET); |
1356 |
|
WriteMacInt32(pb + ioFlBkDat, 0); |
1357 |
|
if (S_ISDIR(st.st_mode)) { |
1358 |
< |
memset(Mac2HostAddr(pb + ioDrUsrWds), 0, SIZEOF_DInfo); |
1359 |
< |
memset(Mac2HostAddr(pb + ioDrFndrInfo), 0, SIZEOF_DXInfo); |
1358 |
> |
Mac_memset(pb + ioDrUsrWds, 0, SIZEOF_DInfo); |
1359 |
> |
Mac_memset(pb + ioDrFndrInfo, 0, SIZEOF_DXInfo); |
1360 |
|
uint16 fflags; // pb may point to kernel space, but stack is switched |
1361 |
|
get_finder_flags(full_path, fflags); |
1362 |
|
WriteMacInt16(pb + ioDrUsrWds + frFlags, fflags); |
1374 |
|
de = readdir(d); |
1375 |
|
if (de == NULL) |
1376 |
|
break; |
1377 |
+ |
if (de->d_name[0] == '.') |
1378 |
+ |
continue; // Suppress names beginning with '.' |
1379 |
|
count++; |
1380 |
|
} |
1381 |
|
closedir(d); |
1384 |
|
} |
1385 |
|
WriteMacInt16(pb + ioDrNmFls, count); |
1386 |
|
} else { |
1387 |
< |
memset(Mac2HostAddr(pb + ioFlFndrInfo), 0, SIZEOF_FInfo); |
1388 |
< |
memset(Mac2HostAddr(pb + ioFlXFndrInfo), 0, SIZEOF_FXInfo); |
1387 |
> |
Mac_memset(pb + ioFlFndrInfo, 0, SIZEOF_FInfo); |
1388 |
> |
Mac_memset(pb + ioFlXFndrInfo, 0, SIZEOF_FXInfo); |
1389 |
|
uint32 type, creator; // pb may point to kernel space, but stack is switched |
1390 |
|
get_finder_type(full_path, type, creator); |
1391 |
|
WriteMacInt32(pb + ioFlFndrInfo + fdType, type); |
1776 |
|
|
1777 |
|
// Read |
1778 |
|
size_t actual = extfs_read(fd, Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), ReadMacInt32(pb + ioReqCount)); |
1779 |
+ |
int16 read_err = errno2oserr(); |
1780 |
|
D(bug(" actual %d\n", actual)); |
1781 |
|
WriteMacInt32(pb + ioActCount, actual); |
1782 |
|
uint32 pos = lseek(fd, 0, SEEK_CUR); |
1783 |
|
WriteMacInt32(fcb + fcbCrPs, pos); |
1784 |
|
WriteMacInt32(pb + ioPosOffset, pos); |
1785 |
|
if (actual != ReadMacInt32(pb + ioReqCount)) |
1786 |
< |
if (errno) |
1781 |
< |
return errno2oserr(); |
1782 |
< |
else |
1783 |
< |
return eofErr; |
1786 |
> |
return read_err ? read_err : eofErr; |
1787 |
|
else |
1788 |
|
return noErr; |
1789 |
|
} |
1825 |
|
|
1826 |
|
// Write |
1827 |
|
size_t actual = extfs_write(fd, Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), ReadMacInt32(pb + ioReqCount)); |
1828 |
+ |
int16 write_err = errno2oserr(); |
1829 |
|
D(bug(" actual %d\n", actual)); |
1830 |
|
WriteMacInt32(pb + ioActCount, actual); |
1831 |
|
uint32 pos = lseek(fd, 0, SEEK_CUR); |
1832 |
|
WriteMacInt32(fcb + fcbCrPs, pos); |
1833 |
|
WriteMacInt32(pb + ioPosOffset, pos); |
1834 |
|
if (actual != ReadMacInt32(pb + ioReqCount)) |
1835 |
< |
return errno2oserr(); |
1835 |
> |
return write_err; |
1836 |
|
else |
1837 |
|
return noErr; |
1838 |
|
} |
1853 |
|
return dupFNErr; |
1854 |
|
|
1855 |
|
// Create file |
1856 |
< |
int fd = creat(full_path, 0664); |
1856 |
> |
int fd = creat(full_path, 0666); |
1857 |
|
if (fd < 0) |
1858 |
|
return errno2oserr(); |
1859 |
|
else { |
1878 |
|
return dupFNErr; |
1879 |
|
|
1880 |
|
// Create directory |
1881 |
< |
if (mkdir(full_path, 0775) < 0) |
1881 |
> |
if (mkdir(full_path, 0777) < 0) |
1882 |
|
return errno2oserr(); |
1883 |
|
else { |
1884 |
|
WriteMacInt32(pb + ioDirID, fs_item->id); |
1898 |
|
return result; |
1899 |
|
|
1900 |
|
// Delete file |
1901 |
< |
if (remove(full_path) < 0) { |
1902 |
< |
int16 err = errno2oserr(); |
1903 |
< |
if (errno == EISDIR) { // Workaround for BeOS bug |
1900 |
< |
if (rmdir(full_path) < 0) |
1901 |
< |
return errno2oserr(); |
1902 |
< |
else |
1903 |
< |
return noErr; |
1904 |
< |
} else |
1905 |
< |
return err; |
1906 |
< |
} else |
1901 |
> |
if (!extfs_remove(full_path)) |
1902 |
> |
return errno2oserr(); |
1903 |
> |
else |
1904 |
|
return noErr; |
1905 |
|
} |
1906 |
|
|
1920 |
|
strcpy(old_path, full_path); |
1921 |
|
|
1922 |
|
// Find path for new name |
1923 |
< |
uint8 new_pb[SIZEOF_IOParam]; |
1924 |
< |
memcpy(new_pb, Mac2HostAddr(pb), SIZEOF_IOParam); |
1928 |
< |
WriteMacInt32((uint32)new_pb + ioNamePtr, ReadMacInt32(pb + ioMisc)); |
1923 |
> |
Mac2Mac_memcpy(fs_data + fsPB, pb, SIZEOF_IOParam); |
1924 |
> |
WriteMacInt32(fs_data + fsPB + ioNamePtr, ReadMacInt32(pb + ioMisc)); |
1925 |
|
FSItem *new_item; |
1926 |
< |
result = get_item_and_path((uint32)new_pb, dirID, new_item); |
1926 |
> |
result = get_item_and_path(fs_data + fsPB, dirID, new_item); |
1927 |
|
if (result != noErr) |
1928 |
|
return result; |
1929 |
|
|
1933 |
|
|
1934 |
|
// Rename item |
1935 |
|
D(bug(" renaming %s -> %s\n", old_path, full_path)); |
1936 |
< |
if (rename(old_path, full_path) < 0) |
1936 |
> |
if (!extfs_rename(old_path, full_path)) |
1937 |
|
return errno2oserr(); |
1938 |
|
else { |
1939 |
|
// The ID of the old file/dir has to stay the same, so we swap the IDs of the FSItems |
1960 |
|
strcpy(old_path, full_path); |
1961 |
|
|
1962 |
|
// Find path for new directory |
1963 |
< |
uint8 new_pb[SIZEOF_IOParam]; |
1964 |
< |
memcpy(new_pb, Mac2HostAddr(pb), SIZEOF_IOParam); |
1969 |
< |
WriteMacInt32((uint32)new_pb + ioNamePtr, ReadMacInt32(pb + ioNewName)); |
1963 |
> |
Mac2Mac_memcpy(fs_data + fsPB, pb, SIZEOF_IOParam); |
1964 |
> |
WriteMacInt32(fs_data + fsPB + ioNamePtr, ReadMacInt32(pb + ioNewName)); |
1965 |
|
FSItem *new_dir_item; |
1966 |
< |
result = get_item_and_path((uint32)new_pb, ReadMacInt32(pb + ioNewDirID), new_dir_item); |
1966 |
> |
result = get_item_and_path(fs_data + fsPB, ReadMacInt32(pb + ioNewDirID), new_dir_item); |
1967 |
|
if (result != noErr) |
1968 |
|
return result; |
1969 |
|
|
1976 |
|
|
1977 |
|
// Move item |
1978 |
|
D(bug(" moving %s -> %s\n", old_path, full_path)); |
1979 |
< |
if (rename(old_path, full_path) < 0) |
1979 |
> |
if (!extfs_rename(old_path, full_path)) |
1980 |
|
return errno2oserr(); |
1981 |
|
else { |
1982 |
|
// The ID of the old file/dir has to stay the same, so we swap the IDs of the FSItems |
2000 |
|
D(bug(" allocating WDCB\n")); |
2001 |
|
r.a[0] = pb; |
2002 |
|
Execute68k(fs_data + fsAllocateWDCB, &r); |
2003 |
< |
D(bug(" UTAllocateWDCB returned %d\n", r.d[0])); |
2003 |
> |
D(bug(" UTAllocateWDCB returned %d, refNum is %d\n", r.d[0], ReadMacInt16(pb + ioVRefNum))); |
2004 |
|
return r.d[0]; |
2005 |
|
} |
2006 |
|
|
2029 |
|
WriteMacInt32(pb + ioWDProcID, 0); |
2030 |
|
WriteMacInt16(pb + ioWDVRefNum, ReadMacInt16(vcb + vcbVRefNum)); |
2031 |
|
if (ReadMacInt32(pb + ioNamePtr)) |
2032 |
< |
memcpy(Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), Mac2HostAddr(vcb + vcbVN), 28); |
2032 |
> |
Mac2Mac_memcpy(ReadMacInt32(pb + ioNamePtr), vcb + vcbVN, 28); |
2033 |
|
WriteMacInt32(pb + ioWDDirID, ROOT_ID); |
2034 |
|
return noErr; |
2035 |
|
} |
2047 |
|
return r.d[0]; |
2048 |
|
|
2049 |
|
// Return information |
2050 |
< |
WriteMacInt16(pb + ioWDProcID, ReadMacInt32(wdcb + wdProcID)); |
2050 |
> |
WriteMacInt32(pb + ioWDProcID, ReadMacInt32(wdcb + wdProcID)); |
2051 |
|
WriteMacInt16(pb + ioWDVRefNum, ReadMacInt16(ReadMacInt32(wdcb + wdVCBPtr) + vcbVRefNum)); |
2052 |
|
if (ReadMacInt32(pb + ioNamePtr)) |
2053 |
< |
memcpy(Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), Mac2HostAddr(ReadMacInt32(wdcb + wdVCBPtr) + vcbVN), 28); |
2053 |
> |
Mac2Mac_memcpy(ReadMacInt32(pb + ioNamePtr), ReadMacInt32(wdcb + wdVCBPtr) + vcbVN, 28); |
2054 |
|
WriteMacInt32(pb + ioWDDirID, ReadMacInt32(wdcb + wdDirID)); |
2055 |
|
return noErr; |
2056 |
|
} |