void cmd_extractall(Volume* volume, int argc, const char *argv[]) {
HFSPlusCatalogRecord* record;
char cwd[1024];
char* name;
ASSERT(getcwd(cwd, 1024) != NULL, "cannot get current working directory");
if(argc > 1)
record = getRecordFromPath(argv[1], volume, &name, NULL);
else
record = getRecordFromPath("/", volume, &name, NULL);
if(argc > 2) {
ASSERT(chdir(argv[2]) == 0, "chdir");
}
if(record != NULL) {
if(record->recordType == kHFSPlusFolderRecord)
extractAllInFolder(((HFSPlusCatalogFolder*)record)->folderID, volume);
else
printf("Not a folder\n");
} else {
printf("No such file or directory\n");
}
free(record);
ASSERT(chdir(cwd) == 0, "chdir");
}
void fs_cmd_cat(int argc, char** argv) {
if(argc < 3) {
bufferPrintf("usage: %s <device> <partition> <file>\r\n", argv[0]);
return;
}
bdevfs_device_t *dev = bdevfs_open(parseNumber(argv[1]), parseNumber(argv[2]));
if(!dev)
{
bufferPrintf("fs: Failed to open partition.\n");
return;
}
HFSPlusCatalogRecord *record = getRecordFromPath(argv[2], dev->volume, NULL, NULL);
if(record != NULL)
{
if(record->recordType == kHFSPlusFileRecord)
{
uint8_t* buffer;
uint32_t size = readHFSFile((HFSPlusCatalogFile*)record, &buffer, dev->volume);
buffer = realloc(buffer, size + 1);
buffer[size] = '\0';
bufferPrintf("%s\r\n", buffer);
free(buffer);
}
else
bufferPrintf("Not a file, record type: %x\r\n", record->recordType);
}
else
bufferPrintf("No such file or directory\r\n");
free(record);
bdevfs_close(dev);
}
void cmd_extract(Volume* volume, int argc, const char *argv[]) {
HFSPlusCatalogRecord* record;
AbstractFile *outFile;
if(argc < 3) {
printf("Not enough arguments");
return;
}
outFile = createAbstractFileFromFile(fopen(argv[2], "wb"));
if(outFile == NULL) {
printf("cannot create file");
}
record = getRecordFromPath(argv[1], volume, NULL, NULL);
if(record != NULL) {
if(record->recordType == kHFSPlusFileRecord)
writeToFile((HFSPlusCatalogFile*)record, outFile, volume);
else
printf("Not a file\n");
} else {
printf("No such file or directory\n");
}
outFile->close(outFile);
free(record);
}
int chownFile(const char* pathName, uint32_t owner, uint32_t group, Volume* volume) {
HFSPlusCatalogRecord* record;
record = getRecordFromPath(pathName, volume, NULL, NULL);
if(record == NULL) {
return FALSE;
}
if(record->recordType == kHFSPlusFolderRecord) {
((HFSPlusCatalogFolder*)record)->permissions.ownerID = owner;
((HFSPlusCatalogFolder*)record)->permissions.groupID = group;
} else if(record->recordType == kHFSPlusFileRecord) {
((HFSPlusCatalogFile*)record)->permissions.ownerID = owner;
((HFSPlusCatalogFile*)record)->permissions.groupID = group;
} else {
return FALSE;
}
updateCatalog(volume, record);
free(record);
return TRUE;
}
int makeSymlink(const char* pathName, const char* target, Volume* volume) {
io_func* io;
HFSPlusCatalogFile* record;
record = (HFSPlusCatalogFile*) getRecordFromPath3(pathName, volume, NULL, NULL, TRUE, FALSE, kHFSRootFolderID);
if(!record) {
newFile(pathName, volume);
record = (HFSPlusCatalogFile*) getRecordFromPath(pathName, volume, NULL, NULL);
if(!record) {
return FALSE;
}
record->permissions.fileMode |= S_IFLNK;
record->userInfo.fileType = kSymLinkFileType;
record->userInfo.fileCreator = kSymLinkCreator;
updateCatalog(volume, (HFSPlusCatalogRecord*) record);
} else {
if(record->recordType != kHFSPlusFileRecord || (((HFSPlusCatalogFile*)record)->permissions.fileMode & S_IFLNK) != S_IFLNK) {
free(record);
return FALSE;
}
}
io = openRawFile(record->fileID, &record->dataFork, (HFSPlusCatalogRecord*) record, volume);
WRITE(io, 0, strlen(target), (void*) target);
CLOSE(io);
free(record);
return TRUE;
}
int fs_extract(int device, int partition, const char* file, void* location) {
int ret;
bdevfs_device_t *dev = bdevfs_open(device, partition);
if(!dev)
{
bufferPrintf("fs: Cannot open partition hd%d,%d.\n", device, partition);
return -1;
}
HFSPlusCatalogRecord* record = getRecordFromPath(file, dev->volume, NULL, NULL);
if(record != NULL)
{
if(record->recordType == kHFSPlusFileRecord)
{
uint8_t* buffer;
uint32_t size = readHFSFile((HFSPlusCatalogFile*)record, &buffer, dev->volume);
memcpy(location, buffer, size);
free(buffer);
ret = size;
}
else
ret = -1;
}
else
ret = -1;
free(record);
bdevfs_close(dev);
return ret;
}
void cmd_getattr(Volume* volume, int argc, const char *argv[]) {
HFSPlusCatalogRecord* record;
if(argc < 3) {
printf("Not enough arguments");
return;
}
record = getRecordFromPath(argv[1], volume, NULL, NULL);
if(record != NULL) {
HFSCatalogNodeID id;
uint8_t* data;
size_t size;
if(record->recordType == kHFSPlusFileRecord)
id = ((HFSPlusCatalogFile*)record)->fileID;
else
id = ((HFSPlusCatalogFolder*)record)->folderID;
size = getAttribute(volume, id, argv[2], &data);
if(size > 0) {
fwrite(data, size, 1, stdout);
free(data);
} else {
printf("No such attribute\n");
}
} else {
printf("No such file or directory\n");
}
free(record);
}
void createRestoreOptions(Volume* volume, const char *optionsPlist, int SystemPartitionSize, int UpdateBaseband) {
AbstractFile* plistFile;
Dictionary* info;
char* plist;
HFSPlusCatalogRecord* record;
info = NULL;
record = getRecordFromPath(optionsPlist, volume, NULL, NULL);
if(record != NULL && record->recordType == kHFSPlusFileRecord) {
HFSPlusCatalogFile* file = (HFSPlusCatalogFile*)record;
size_t bufferSize = 512;
plist = malloc(bufferSize);
plistFile = createAbstractFileFromMemory((void**)&plist, bufferSize);
if (plistFile) {
char zero = 0;
writeToFile(file, plistFile, volume);
plistFile->write(plistFile, &zero, sizeof(zero));
plistFile->close(plistFile);
info = createRoot(plist);
removeKey(info, "CreateFilesystemPartitions");
removeKey(info, "SystemPartitionSize");
removeKey(info, "UpdateBaseband");
removeKey(info, "MinimumSystemPartition");
addIntegerToDictionary(info, "MinimumSystemPartition", SystemPartitionSize);
XLOG(0, "got %s from ramdisk\n", optionsPlist);
}
free(plist);
}
XLOG(0, "start create restore options\n");
if (!info) info = createRoot("<dict></dict>");
addBoolToDictionary(info, "CreateFilesystemPartitions", TRUE);
addIntegerToDictionary(info, "SystemPartitionSize", SystemPartitionSize);
addBoolToDictionary(info, "UpdateBaseband", UpdateBaseband);
plist = getXmlFromRoot(info);
releaseDictionary(info);
XLOG(0, "%s", plist);
plistFile = createAbstractFileFromMemory((void**)&plist, sizeof(char) * strlen(plist));
add_hfs(volume, plistFile, optionsPlist);
free(plist);
}
void fs_cmd_extract(int argc, char** argv) {
Volume* volume;
io_func* io;
if(argc < 4) {
bufferPrintf("usage: %s <partition> <file> <location>\r\n", argv[0]);
return;
}
io = bdev_open(parseNumber(argv[1]));
if(io == NULL) {
bufferPrintf("fs: cannot read partition!\r\n");
return;
}
volume = openVolume(io);
if(volume == NULL) {
bufferPrintf("fs: cannot openHFS volume!\r\n");
return;
}
HFSPlusCatalogRecord* record;
record = getRecordFromPath(argv[2], volume, NULL, NULL);
if(record != NULL) {
if(record->recordType == kHFSPlusFileRecord) {
uint8_t* buffer;
uint32_t size = readHFSFile((HFSPlusCatalogFile*)record, &buffer, volume);
uint32_t address = parseNumber(argv[3]);
memcpy((uint8_t*)address, buffer, size);
free(buffer);
bufferPrintf("%d bytes of %s extracted to 0x%x\r\n", size, argv[2], address);
} else {
bufferPrintf("Not a file, record type: %x\r\n", record->recordType);
}
} else {
bufferPrintf("No such file or directory\r\n");
}
free(record);
closeVolume(volume);
CLOSE(io);
}
void fs_cmd_cat(int argc, char** argv) {
Volume* volume;
io_func* io;
if(argc < 3) {
bufferPrintf("usage: %s <partition> <file>\r\n", argv[0]);
return;
}
io = bdev_open(parseNumber(argv[1]));
if(io == NULL) {
bufferPrintf("fs: cannot read partition!\r\n");
return;
}
volume = openVolume(io);
if(volume == NULL) {
bufferPrintf("fs: cannot openHFS volume!\r\n");
return;
}
HFSPlusCatalogRecord* record;
record = getRecordFromPath(argv[2], volume, NULL, NULL);
if(record != NULL) {
if(record->recordType == kHFSPlusFileRecord) {
uint8_t* buffer;
uint32_t size = readHFSFile((HFSPlusCatalogFile*)record, &buffer, volume);
buffer = realloc(buffer, size + 1);
buffer[size] = '\0';
bufferPrintf("%s\r\n", buffer);
free(buffer);
} else {
bufferPrintf("Not a file, record type: %x\r\n", record->recordType);
}
} else {
bufferPrintf("No such file or directory\r\n");
}
free(record);
closeVolume(volume);
CLOSE(io);
}
void hfs_ls(Volume* volume, const char* path) {
HFSPlusCatalogRecord* record;
char* name;
record = getRecordFromPath(path, volume, &name, NULL);
if(record != NULL) {
if(record->recordType == kHFSPlusFolderRecord)
displayFolder(((HFSPlusCatalogFolder*)record)->folderID, volume);
else
displayFileLSLine((HFSPlusCatalogFile*)record, name);
} else {
printf("No such file or directory\n");
}
printf("Total filesystem size: %d, free: %d\n", (volume->volumeHeader->totalBlocks - volume->volumeHeader->freeBlocks) * volume->volumeHeader->blockSize, volume->volumeHeader->freeBlocks * volume->volumeHeader->blockSize);
free(record);
}
void get_hfs(Volume* volume, const char* inFileName, AbstractFile* output) {
HFSPlusCatalogRecord* record;
record = getRecordFromPath(inFileName, volume, NULL, NULL);
if(record != NULL) {
if(record->recordType == kHFSPlusFileRecord)
writeToFile((HFSPlusCatalogFile*)record, output, volume);
else {
printf("Not a file\n");
exit(0);
}
} else {
printf("No such file or directory\n");
exit(0);
}
free(record);
}
void cmd_cat(Volume* volume, int argc, const char *argv[]) {
HFSPlusCatalogRecord* record;
AbstractFile* stdoutFile;
record = getRecordFromPath(argv[1], volume, NULL, NULL);
stdoutFile = createAbstractFileFromFile(stdout);
if(record != NULL) {
if(record->recordType == kHFSPlusFileRecord)
writeToFile((HFSPlusCatalogFile*)record, stdoutFile, volume);
else
printf("Not a file\n");
} else {
printf("No such file or directory\n");
}
free(record);
free(stdoutFile);
}
void addall_hfs(Volume* volume, const char* dirToMerge, const char* dest) {
HFSPlusCatalogRecord* record;
char* name;
char cwd[1024];
char initPath[1024];
int lastCharOfPath;
ASSERT(getcwd(cwd, 1024) != NULL, "cannot get current working directory");
if(chdir(dirToMerge) != 0) {
printf("Cannot open that directory: %s\n", dirToMerge);
exit(0);
}
record = getRecordFromPath(dest, volume, &name, NULL);
strcpy(initPath, dest);
lastCharOfPath = strlen(dest) - 1;
if(dest[lastCharOfPath] != '/') {
initPath[lastCharOfPath + 1] = '/';
initPath[lastCharOfPath + 2] = '\0';
}
if(record != NULL) {
if(record->recordType == kHFSPlusFolderRecord)
addAllInFolder(((HFSPlusCatalogFolder*)record)->folderID, volume, initPath);
else {
printf("Not a folder\n");
exit(0);
}
} else {
printf("No such file or directory\n");
exit(0);
}
ASSERT(chdir(cwd) == 0, "chdir");
free(record);
}
int chmodFile(const char* pathName, int mode, Volume* volume) {
HFSPlusCatalogRecord* record;
record = getRecordFromPath(pathName, volume, NULL, NULL);
if(record == NULL) {
return FALSE;
}
if(record->recordType == kHFSPlusFolderRecord) {
((HFSPlusCatalogFolder*)record)->permissions.fileMode = (((HFSPlusCatalogFolder*)record)->permissions.fileMode & 0770000) | mode;
} else if(record->recordType == kHFSPlusFileRecord) {
((HFSPlusCatalogFile*)record)->permissions.fileMode = (((HFSPlusCatalogFolder*)record)->permissions.fileMode & 0770000) | mode;
} else {
return FALSE;
}
updateCatalog(volume, record);
free(record);
return TRUE;
}
HFSCatalogNodeID newFolder(const char* pathName, Volume* volume) {
HFSPlusCatalogFolder* parentFolder;
HFSPlusCatalogFolder folder;
HFSPlusCatalogKey key;
HFSPlusCatalogThread thread;
uint32_t newFolderID;
int threadLength;
char* path;
char* name;
char* curChar;
char* lastSeparator;
path = strdup(pathName);
curChar = path;
lastSeparator = NULL;
while((*curChar) != '\0') {
if((*curChar) == '/')
lastSeparator = curChar;
curChar++;
}
if(lastSeparator == NULL) {
parentFolder = (HFSPlusCatalogFolder*) getRecordFromPath("/", volume, NULL, NULL);
name = path;
} else {
name = lastSeparator + 1;
*lastSeparator = '\0';
parentFolder = (HFSPlusCatalogFolder*) getRecordFromPath(path, volume, NULL, NULL);
}
if(parentFolder == NULL || parentFolder->recordType != kHFSPlusFolderRecord) {
free(path);
free(parentFolder);
return FALSE;
}
newFolderID = volume->volumeHeader->nextCatalogID++;
volume->volumeHeader->folderCount++;
folder.recordType = kHFSPlusFolderRecord;
folder.flags = kHFSHasFolderCountMask;
folder.valence = 0;
folder.folderID = newFolderID;
folder.createDate = UNIX_TO_APPLE_TIME(time(NULL));
folder.contentModDate = folder.createDate;
folder.attributeModDate = folder.createDate;
folder.accessDate = folder.createDate;
folder.backupDate = folder.createDate;
folder.permissions.ownerID = parentFolder->permissions.ownerID;
folder.permissions.groupID = parentFolder->permissions.groupID;
folder.permissions.adminFlags = 0;
folder.permissions.ownerFlags = 0;
folder.permissions.fileMode = S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
folder.permissions.special.iNodeNum = 0;
memset(&folder.userInfo, 0, sizeof(folder.userInfo));
memset(&folder.finderInfo, 0, sizeof(folder.finderInfo));
folder.textEncoding = 0;
folder.folderCount = 0;
key.parentID = parentFolder->folderID;
ASCIIToUnicode(name, &key.nodeName);
key.keyLength = sizeof(key.parentID) + STR_SIZE(key.nodeName);
thread.recordType = kHFSPlusFolderThreadRecord;
thread.reserved = 0;
thread.parentID = parentFolder->folderID;
ASCIIToUnicode(name, &thread.nodeName);
threadLength = sizeof(thread.recordType) + sizeof(thread.reserved) + sizeof(thread.parentID) + STR_SIZE(thread.nodeName);
flipCatalogThread(&thread, TRUE);
flipCatalogFolder(&folder);
ASSERT(addToBTree(volume->catalogTree, (BTKey*)(&key), sizeof(HFSPlusCatalogFolder), (unsigned char *)(&folder)), "addToBTree");
key.nodeName.length = 0;
key.parentID = newFolderID;
key.keyLength = sizeof(key.parentID) + sizeof(key.nodeName.length);
ASSERT(addToBTree(volume->catalogTree, (BTKey*)(&key), threadLength, (unsigned char *)(&thread)), "addToBTree");
parentFolder->folderCount++;
parentFolder->valence++;
updateCatalog(volume, (HFSPlusCatalogRecord*) parentFolder);
updateVolume(volume);
free(parentFolder);
free(path);
return newFolderID;
}
ExtentList* fs_get_extents(int device, int partition, const char* fileName) {
unsigned int partitionStart;
unsigned int physBlockSize;
ExtentList* list = NULL;
bdevfs_device_t *dev = bdevfs_open(device, partition);
if(!dev)
return NULL;
physBlockSize = block_device_block_size(dev->handle->device);
partitionStart = block_device_get_start(dev->handle);
HFSPlusCatalogRecord* record = getRecordFromPath(fileName, dev->volume, NULL, NULL);
if(record != NULL) {
if(record->recordType == kHFSPlusFileRecord) {
io_func* fileIO;
HFSPlusCatalogFile* file = (HFSPlusCatalogFile*) record;
unsigned int allocationBlockSize = dev->volume->volumeHeader->blockSize;
int numExtents = 0;
Extent* extent;
int i;
fileIO = openRawFile(file->fileID, &file->dataFork, record, dev->volume);
if(!fileIO)
goto out_free;
extent = ((RawFile*)fileIO->data)->extents;
while(extent != NULL)
{
numExtents++;
extent = extent->next;
}
list = (ExtentList*) malloc(sizeof(ExtentList));
list->numExtents = numExtents;
extent = ((RawFile*)fileIO->data)->extents;
for(i = 0; i < list->numExtents; i++)
{
list->extents[i].startBlock = partitionStart + (extent->startBlock * (allocationBlockSize / physBlockSize));
list->extents[i].blockCount = extent->blockCount * (allocationBlockSize / physBlockSize);
extent = extent->next;
}
CLOSE(fileIO);
} else {
goto out_free;
}
} else {
goto out_close;
}
out_free:
free(record);
out_close:
bdevfs_close(dev);
return list;
}
int move(const char* source, const char* dest, Volume* volume) {
HFSPlusCatalogRecord* srcRec;
HFSPlusCatalogFolder* srcFolderRec;
HFSPlusCatalogFolder* destRec;
char* destPath;
char* destName;
char* curChar;
char* lastSeparator;
int i;
int threadLength;
HFSPlusCatalogKey srcKey;
HFSPlusCatalogKey destKey;
HFSPlusCatalogThread* thread;
srcRec = getRecordFromPath3(source, volume, NULL, &srcKey, TRUE, FALSE, kHFSRootFolderID);
if(srcRec == NULL) {
free(srcRec);
return FALSE;
}
srcFolderRec = (HFSPlusCatalogFolder*) getRecordByCNID(srcKey.parentID, volume);
if(srcFolderRec == NULL || srcFolderRec->recordType != kHFSPlusFolderRecord) {
free(srcRec);
free(srcFolderRec);
return FALSE;
}
destPath = strdup(dest);
curChar = destPath;
lastSeparator = NULL;
while((*curChar) != '\0') {
if((*curChar) == '/')
lastSeparator = curChar;
curChar++;
}
if(lastSeparator == NULL) {
destRec = (HFSPlusCatalogFolder*) getRecordFromPath("/", volume, NULL, NULL);
destName = destPath;
} else {
destName = lastSeparator + 1;
*lastSeparator = '\0';
destRec = (HFSPlusCatalogFolder*) getRecordFromPath(destPath, volume, NULL, NULL);
if(destRec == NULL || destRec->recordType != kHFSPlusFolderRecord) {
free(destPath);
free(srcRec);
free(destRec);
free(srcFolderRec);
return FALSE;
}
}
removeFromBTree(volume->catalogTree, (BTKey*)(&srcKey));
srcKey.nodeName.length = 0;
if(srcRec->recordType == kHFSPlusFolderRecord) {
srcKey.parentID = ((HFSPlusCatalogFolder*)srcRec)->folderID;
} else if(srcRec->recordType == kHFSPlusFileRecord) {
srcKey.parentID = ((HFSPlusCatalogFile*)srcRec)->fileID;
} else {
/* unexpected */
return FALSE;
}
srcKey.keyLength = sizeof(srcKey.parentID) + sizeof(srcKey.nodeName.length);
removeFromBTree(volume->catalogTree, (BTKey*)(&srcKey));
destKey.nodeName.length = strlen(destName);
threadLength = sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint16_t) + (sizeof(uint16_t) * destKey.nodeName.length);
thread = (HFSPlusCatalogThread*) malloc(threadLength);
thread->reserved = 0;
destKey.parentID = destRec->folderID;
thread->parentID = destKey.parentID;
thread->nodeName.length = destKey.nodeName.length;
for(i = 0; i < destKey.nodeName.length; i++) {
destKey.nodeName.unicode[i] = destName[i];
thread->nodeName.unicode[i] = destName[i];
}
destKey.keyLength = sizeof(uint32_t) + sizeof(uint16_t) + (sizeof(uint16_t) * destKey.nodeName.length);
switch(srcRec->recordType) {
case kHFSPlusFolderRecord:
thread->recordType = kHFSPlusFolderThreadRecord;
flipCatalogFolder((HFSPlusCatalogFolder*)srcRec);
addToBTree(volume->catalogTree, (BTKey*)(&destKey), sizeof(HFSPlusCatalogFolder), (unsigned char *)(srcRec));
break;
case kHFSPlusFileRecord:
thread->recordType = kHFSPlusFileThreadRecord;
flipCatalogFile((HFSPlusCatalogFile*)srcRec);
addToBTree(volume->catalogTree, (BTKey*)(&destKey), sizeof(HFSPlusCatalogFile), (unsigned char *)(srcRec));
break;
}
destKey.nodeName.length = 0;
destKey.parentID = srcKey.parentID;
destKey.keyLength = sizeof(destKey.parentID) + sizeof(destKey.nodeName.length);
flipCatalogThread(thread, TRUE);
addToBTree(volume->catalogTree, (BTKey*)(&destKey), threadLength, (unsigned char *)(thread));
/* adjust valence */
srcFolderRec->valence--;
updateCatalog(volume, (HFSPlusCatalogRecord*) srcFolderRec);
destRec->valence++;
updateCatalog(volume, (HFSPlusCatalogRecord*) destRec);
free(thread);
free(destPath);
free(srcRec);
free(destRec);
free(srcFolderRec);
return TRUE;
}
void startScripting(char* loadedFrom)
{
uint32_t size = 0;
uint8_t* address = NULL;
const char* partitionScript = nvram_getvar("partition-script"); /*get the partition where the script is in NVRAM*/
const char* fileScript = nvram_getvar("file-script"); /*get the path to the file script in NVRAM*/
const char* scriptingLinux = nvram_getvar("scripting-linux"); /*tells whether to run the script before booting linux. Accepted values : true or 1, anything else if false*/
const char* scriptingOpeniboot = nvram_getvar("scripting-openiboot"); /*tells whether to run the script before launching openiboot console. Accepted values : true or 1, anything else if false*/
//uint32_t numberOfLines = 1; /*number of lines in the script files - To be used with the next commented section of code for debug*/
//bufferPrintf("partition-script %s\r\n",partitionScript); /*For debug*/
//bufferPrintf("file-script %s\r\n",fileScript); /*For debug*/
if(!partitionScript)
return;
if(!fileScript)
return;
/* ------ extracting the script file at address 0x09000000 ----- */
if(strcmp(loadedFrom, "linux") == 0)
{
if(!scriptingLinux || (strcmp(scriptingLinux, "true") != 0 && strcmp(scriptingLinux, "1") != 0))
{
return; /* terminate the function if scripting is not asked*/
}
}
if(strcmp(loadedFrom, "openiboot") == 0)
{
if(!scriptingOpeniboot || (strcmp(scriptingOpeniboot, "true") != 0 && strcmp(scriptingOpeniboot, "1") != 0))
{
return; /* terminate the function if scripting is not asked*/
}
}
Volume* volume;
io_func* io;
io = bdev_open(parseNumber(partitionScript));
if(io == NULL) {
bufferPrintf("fs: cannot read partition!\r\n");
return;
}
volume = openVolume(io);
if(volume == NULL) {
bufferPrintf("fs: cannot openHFS volume!\r\n");
return;
}
HFSPlusCatalogRecord* record;
char* name;
record = getRecordFromPath(fileScript, volume, &name, NULL);
if(record != NULL) {
if(record->recordType == kHFSPlusFolderRecord)
{
bufferPrintf("this path is a folder, not a file\r\n");
return;
} else
{
size = readHFSFile((HFSPlusCatalogFile*)record, &address, volume);
if(!address)
return;
//bufferPrintf("size = %d\r\n",size); /*size of script file, used later*/
}
} else {
bufferPrintf("No such file or directory\r\n");
return;
}
closeVolume(volume);
CLOSE(io);
char* addrBOF = (char*) address; /* pointer on the begening of the file*/
char* addrEOF = (char*) (address + size); /*pointer 1 byte after the file */
char* addr; /*pointer on the current space on memory*/
#if 0
//addrEOF = (void*)address+size+1;
/* ----- counting how many lines are present in the script file by the '\n' ----- */
addr = addrBOF;
while(addr < addrEOF)
{
if(*addr=='\r'){
numberOfLines++;
}
addr++;
}
bufferPrintf("number of lines : %d\r\n", numberOfLines);
#endif
char* bufferLine = malloc(100);
/* ----- extracting each line to the buffer -----*/
addr = addrBOF;
while(addr < addrEOF)
{
int charAt = 0;
while((*addr != '\n') && (addr < addrEOF))
{
if(*addr != '\r')
{
bufferLine[charAt] = *addr;
//bufferPrintf("reading char : %c\r\n",*addr);
charAt++;
}
addr++;
}
bufferLine[charAt]='\0';
bufferPrintf("\r\n%s\r\n", bufferLine);
bufferLine[charAt]='\n';
bufferLine[charAt + 1] = '\0';
if(scriptCommand(bufferLine))
{
//bufferPrintf("command sent\r\n");
}
/*else { //error in command, function scriptCommand returned false
}*/
addr++;
}
free(bufferLine);
free(address);
}
int attrFile(const char* pathName, const char* flags, Volume* volume) {
HFSPlusCatalogRecord* record;
uint16_t flag = 0;
uint16_t mask = 0;
uint16_t file_mask = kIsOnDesk|kColor|kIsShared|kHasNoINITs|kHasBeenInited|kHasCustomIcon|kIsStationery|kNameLocked|kHasBundle|kIsInvisible|kIsAlias;
uint16_t folder_mask = kIsOnDesk|kColor|kHasCustomIcon|kNameLocked|kIsInvisible;
while (*flags != 0) {
switch(*flags++) {
// custom icon
case 'C':
flag |= kHasCustomIcon;
case 'c':
mask |= kHasCustomIcon;
break;
// invisible
case 'V':
flag |= kIsInvisible;
case 'v':
mask |= kIsInvisible;
break;
// inited
case 'I':
flag |= kHasBeenInited;
case 'i':
mask |= kHasBeenInited;
break;
// no INIT resource
case 'N':
flag |= kHasNoINITs;
case 'n':
mask |= kHasNoINITs;
break;
// located on the desktop
case 'D':
flag |= kIsOnDesk;
case 'd':
mask |= kIsOnDesk;
break;
// name locked
case 'S':
flag |= kNameLocked;
case 's':
mask |= kNameLocked;
break;
// stationery pad file
case 'T':
flag |= kIsStationery;
case 't':
mask |= kIsStationery;
break;
// shared
case 'M':
flag |= kIsShared;
case 'm':
mask |= kIsShared;
break;
// alias file
case 'A':
flag |= kIsAlias;
case 'a':
mask |= kIsAlias;
break;
// has bundle
case 'B':
flag |= kHasBundle;
case 'b':
mask |= kHasBundle;
break;
}
}
record = getRecordFromPath(pathName, volume, NULL, NULL);
if(record == NULL) {
printf("Path '%s' not found.\n", pathName);
return FALSE;
}
if(record->recordType == kHFSPlusFolderRecord) {
flag &= folder_mask;
mask &= folder_mask;
((HFSPlusCatalogFolder*)record)->userInfo.finderFlags = (((HFSPlusCatalogFolder*)record)->userInfo.finderFlags & (~mask)) | flag;
printf("%x\n", ((HFSPlusCatalogFolder*)record)->userInfo.finderFlags);
} else if(record->recordType == kHFSPlusFileRecord) {
flag &= file_mask;
mask &= file_mask;
((HFSPlusCatalogFile*)record)->userInfo.finderFlags = (((HFSPlusCatalogFile*)record)->userInfo.finderFlags & (~mask)) | flag;
printf("%x\n", ((HFSPlusCatalogFile*)record)->userInfo.finderFlags);
} else {
printf("unknown record type %x\n", record->recordType);
return FALSE;
}
updateCatalog(volume, record);
free(record);
return TRUE;
}