// Method reads all (interesting)directory entries from Iges Cad-file
// and stores them into attribute "directory" (container)
int
InputIges::readDirectory()
{
fieldBuffer[1+DIR_FLD_LEN] = '\0';
lineBuffer[SEC_ID_POS] = ' ';
while (!infile.eof() && lineBuffer[SEC_ID_POS] != 'D')
readFileLine(infile, lineBuffer);
if (infile.eof())
return 0;
IgesDirectoryEntry* de;
int cur_file_pos = infile.tellg();
while (!infile.eof() && lineBuffer[SEC_ID_POS] == 'D') {
de = readDirectoryEntry(lineBuffer);
//-Add geometry-use types to directory
//if (de->status.useFlag == 0)
// addToDirectory(de);
// Currently all entries are added to directory.
// The problem is: what entries could be excluded? !!!
addToDirectory(de);
//-Read the first line of next entry
cur_file_pos = infile.tellg();
readFileLine(infile, lineBuffer);
}
return cur_file_pos;
}
bool ICOImageDecoder::processDirectoryEntries()
{
// Read directory entries.
ASSERT(m_decodedOffset == sizeOfDirectory);
if ((m_decodedOffset > m_data->size()) || ((m_data->size() - m_decodedOffset) < (m_dirEntries.size() * sizeOfDirEntry)))
return false;
for (IconDirectoryEntries::iterator i(m_dirEntries.begin()); i != m_dirEntries.end(); ++i)
*i = readDirectoryEntry(); // Updates m_decodedOffset.
// Make sure the specified image offsets are past the end of the directory
// entries.
for (IconDirectoryEntries::iterator i(m_dirEntries.begin()); i != m_dirEntries.end(); ++i) {
if (i->m_imageOffset < m_decodedOffset)
return setFailed();
}
// Arrange frames in decreasing quality order.
std::sort(m_dirEntries.begin(), m_dirEntries.end(), compareEntries);
// The image size is the size of the largest entry.
const IconDirectoryEntry& dirEntry = m_dirEntries.first();
// Technically, this next call shouldn't be able to fail, since the width
// and height here are each <= 256, and |m_frameSize| is empty.
return setSize(dirEntry.m_size.width(), dirEntry.m_size.height());
}
/*!
*****************************************************************************
* \brief
* Read the ImageFileDirectory.
*
*****************************************************************************
*/
static int readImageFileDirectory (Tiff * t)
{
uint32 i;
uint32 nEntries = t->getU16( t);
for (i=0; i < nEntries; ++i)
{
readDirectoryEntry( t);
}
return 0;
}
/**
* @brief Reads a folder listing, prints all items and adds all subdirectories to the global queue
* @param offset where the first directory entry of the folder structure begins
*/
void listDirectory(unsigned int offset) {
// do not read into next cluster
long maxOffset = offset + (bootsector->BPB.sectorspercluster * bootsector->BPB.sectorsize);
long newOffset = offset;
lseek(handle, newOffset, SEEK_SET);
// the reference point in the list where we want to add the subdirectories
// by default, we want to add subdirectories to the top so that we get depth-first search
DIRENTRY* referencePoint = firstDirItem->directoryEntry;
// this is where we read into
DIRENTRY* directoryEntry;
// in case we have to handle VFAT / LFN entries, prepare the buffer
char LFN[260];
while((newOffset < maxOffset) && (directoryEntry = readDirectoryEntry())) {
// we need to preserve the offset in case any operations move the file pointer
//newOffset = tell(handle);
newOffset = lseek(handle, 0, SEEK_CUR);
if(memcmp(directoryEntry->name, dot, 8) == 0) {
char buf2[1024];
absoluteDirectoryPath(directoryEntry, buf2);
printf("Directory of %s\n", buf2);
}
if(directoryEntry->attr == DIRENTRY_ATTR_VFAT) {
printf("this is a VFAT entry!\n");
handleLFN(directoryEntry, LFN);
}else{
printDirectoryEntry(directoryEntry);
}
if(isDirectory(directoryEntry)) {
// add subdirectories to the queue
// please ignore the current directory entry ('.') and parent ('..')
if((memcmp(directoryEntry->name, dot, 8) != 0) && (memcmp(directoryEntry->name, dotdot, 8) != 0)) {
dir_insert(referencePoint, directoryEntry);
referencePoint = directoryEntry;
//dir_push_back(directoryEntry);
}
}
lseek(handle, newOffset, SEEK_SET);
}
}
/**
* @brief parentDirectory
* @param currentDirectoryEntry
* @return parent DIRENTRY*
*/
DIRENTRY* parentDirectory(DIRENTRY* currentDirectoryEntry) {
lseek(handle, getclusteroffset(currentDirectoryEntry->firstcluser), SEEK_SET);
DIRENTRY* directoryEntry = 0;
DIRENTRY* parentDirectoryEntry = 0;
// read current directory, find parent entry ('..')
while(directoryEntry = readDirectoryEntry()) {
if(memcmp(directoryEntry->name, dotdot, 8) == 0) {
parentDirectoryEntry = directoryEntry;
break;
}
}
return parentDirectoryEntry;
}
/**
* @brief Retrieves the current folder's name (handy if you only have a '.' entry at hand)
* @param currentDirectoryEntry
* @param buf is a buffer big enough to hold the folder name
*/
void currentFolderName(DIRENTRY* currentDirectoryEntry, char* buf) {
DIRENTRY* directoryEntry;
DIRENTRY* parentDirectoryEntry = 0;
parentDirectoryEntry = parentDirectory(currentDirectoryEntry);
// read parent directory, find entry that matches current (original) folder's first cluster
lseek(handle, getclusteroffset(parentDirectoryEntry->firstcluser), SEEK_SET);
while(directoryEntry = readDirectoryEntry()) {
if(directoryEntry->firstcluser == currentDirectoryEntry->firstcluser) {
formatDirectoryEntryName(directoryEntry, buf);
return;
}
}
}
bool ICOImageDecoder::processDirectoryEntries() {
// Read directory entries.
ASSERT(m_decodedOffset == sizeOfDirectory);
if ((m_decodedOffset > m_data->size()) ||
((m_data->size() - m_decodedOffset) <
(m_dirEntriesCount * sizeOfDirEntry)))
return false;
// Enlarge member vectors to hold all the entries.
m_dirEntries.resize(m_dirEntriesCount);
m_bmpReaders.resize(m_dirEntriesCount);
m_pngDecoders.resize(m_dirEntriesCount);
for (IconDirectoryEntries::iterator i(m_dirEntries.begin());
i != m_dirEntries.end(); ++i)
*i = readDirectoryEntry(); // Updates m_decodedOffset.
// Make sure the specified image offsets are past the end of the directory
// entries.
for (IconDirectoryEntries::iterator i(m_dirEntries.begin());
i != m_dirEntries.end(); ++i) {
if (i->m_imageOffset < m_decodedOffset)
return setFailed();
}
DEFINE_THREAD_SAFE_STATIC_LOCAL(
blink::CustomCountHistogram, dimensionsLocationHistogram,
new blink::CustomCountHistogram(
"Blink.DecodedImage.EffectiveDimensionsLocation.ICO", 0, 50000, 50));
dimensionsLocationHistogram.count(m_decodedOffset - 1);
// Arrange frames in decreasing quality order.
std::sort(m_dirEntries.begin(), m_dirEntries.end(), compareEntries);
// The image size is the size of the largest entry.
const IconDirectoryEntry& dirEntry = m_dirEntries.first();
// Technically, this next call shouldn't be able to fail, since the width
// and height here are each <= 256, and |m_frameSize| is empty.
return setSize(dirEntry.m_size.width(), dirEntry.m_size.height());
}
/*
* Caches a directory block
*/
void CachedDirectory::cacheDirectoryBlock(int blockNumber) {
// read the directory header
cachedDirectoryLastBlockHeader = readDirectoryHeader(blockNumber);
// calculate number of entries
int numberOfEntries = (superBlock->getBlockSize() - cachedDirectoryLastBlockHeader.data.startOfLastNode) / directoryEntrySize;
// read the directory names
string names = readDirectoryEntryNames(blockNumber, numberOfEntries, cachedDirectoryLastBlockHeader.data.endOfLastName);
string currentName = "";// cache the root directory
unsigned int namesPointer = 0;
// read entries
for (int i=numberOfEntries-1;i>-1;i--) {
DirectoryEntryData entry = readDirectoryEntry(blockNumber, i);
namesPointer = entry.data.nameOffset - directoryHeaderSize;
while (namesPointer < names.length() && names.at(namesPointer)!='\0') {
currentName += names.at(namesPointer);
namesPointer++;
}
cache.insert({currentName,entry.data.iNodeRef});
currentName.clear();
namesPointer++;
}
}
int main (int argc, const char * argv[]) {
FILE* fp;// = fopen("samplefat.bin", "rb");
if (argc == 2) {
fp = fopen(argv[1], "rb");
if(fp == NULL)
{
printf("Invalid file path.\n");
return 0;
}
}
else {
printf("usage: %s %s\n", argv[0], "sample.bin");
return 1;
}
BootStrapSector bss;
readBootStrapSector(&bss, fp);
if(bss.magic55AA[0] != 0x55 || bss.magic55AA[1] !=0xAA)
{
printf("Invalid FAT-12 file.\n");
return 1;
}
sector_t rootDirectorySector = FIRST_FAT_SECTOR + bss.numSectorsInFAT * bss.numCopiesFAT;
size_t numSectorsInDirectory = bss.numEntriesRootDir * 32 / bss.numBytesPerSector;
sector_t firstClusterSector = rootDirectorySector + numSectorsInDirectory;
seekToSector(fp, rootDirectorySector, bss.numBytesPerSector);
// Extract
int i;
int fileCounter = 0;
seekToSector(fp, rootDirectorySector, bss.numBytesPerSector);
printf("Extracting...\n");
for (i = 0; i < bss.numEntriesRootDir; i++)
{
DirectoryEntry de;
readDirectoryEntry(&de, fp);
if (isFile(&de))
{
fileCounter++;
long offsetToNextDirectoryEntry = ftell(fp);
printf("%s.%s%s", de.filename, de.file_extension, (i < bss.numEntriesRootDir ? ", " : "\n"));
FILE* fat_file_p = fopen(de.filename, "wb");
UINT16 curCluster = de.start_cluster;
//printf("%x\n", curCluster);
BYTE buffer[bss.numBytesPerSector * bss.numSectorsPerCluster];
int fileSize = de.file_size;
while (curCluster < 0xFF8 && fileSize > 0)
{
readCluster(fp, curCluster, firstClusterSector, bss.numBytesPerSector, bss.numSectorsPerCluster, buffer);
//}
if(fileSize < bss.numBytesPerSector * bss.numSectorsPerCluster)
{
fwrite(buffer, sizeof(BYTE), fileSize, fat_file_p);
}
else
{
fwrite(buffer, sizeof(BYTE), sizeof(buffer), fat_file_p);
}
seekToSector(fp, FIRST_FAT_SECTOR, bss.numBytesPerSector);
curCluster = extract12File(fp, curCluster);
fileSize -= bss.numBytesPerSector * bss.numSectorsPerCluster;
}
fclose(fat_file_p);
fseek(fp, offsetToNextDirectoryEntry, SEEK_SET);
}
}
printf("\nExtracted: %i files\n", fileCounter);
fclose(fp);
return 0;
}
