示例#1
0
static tsize_t
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
{
	return (FSRead((short) fd, (long*) &size, (char*) buf) == noErr ?
	    size : (tsize_t) -1);
}
示例#2
0
//filepath = fullpath
// 0 = not exist, 1=success, -1=failed
static s8 _Open(hFILE fp, const FSPath & fsPath, const tCHAR *filepath, const tCHAR *mode)
{
	s8 ret = FALSE;

	//get the write mode
	u8 bWriteMode = FALSE; //we are going to write on the file?

	tCHAR *modePtr = (tCHAR*)mode;
	while(*modePtr != 0) { if(*modePtr == 'w') { bWriteMode = TRUE; break; } modePtr++; }

	if(TESTFLAGS(fsPath.flag, FS_DIR_ARCHIVE))
	{
		//are we trying to write?
		//say it doesn't exist.
		if(bWriteMode)
			return 0;

		char sPath[MAXCHARBUFF]; wcstombs(sPath, filepath, MAXCHARBUFF);

		//switch all '\' to '/'
		u32 sSize = (u32)strlen(sPath);
		for(u32 i = 0; i < sSize; i++)
		{
			if(sPath[i] == '\\') sPath[i] = '/';
		}

		if(fsPath.uf)
		{
			//check to see if the given filepath is in the zip
			if(unzLocateFile(fsPath.uf, sPath, 2) == UNZ_OK)
			{
				unz_file_info file_info;

				unzGetCurrentFileInfo(fsPath.uf, &file_info, sPath, MAXCHARBUFF, 0,0,0,0);

				if(unzOpenCurrentFile(fsPath.uf) == UNZ_OK)
				{
					//allocate the buffer for this file
					fp->buff = (u8*)MemAlloc(sizeof(u8)*file_info.uncompressed_size);

					if(fp->buff)
					{
						//copy the data to the buffer
						unzReadCurrentFile(fsPath.uf, (voidp)fp->buff, file_info.uncompressed_size);

						fp->buffSize = file_info.uncompressed_size;

						//check for unicode (we only use UC_Base/UC_BigEndian for now...)
						if(fp->buff[0] == 0xff && fp->buff[1] == 0xfe)
							fp->uCType = UC_Base;
						else if(fp->buff[0] == 0xfe && fp->buff[1] == 0xff)
							fp->uCType = UC_BigEndian;

						ret = TRUE;
					}
					else { ret = -1; LogMsg(LOG_FILE, L"_Open: unable to allocate buffer", filepath); }

					unzCloseCurrentFile(fsPath.uf);
				}
				else { ret = -1; LogMsg(LOG_FILE, L"_Open: unable to open file in archive", filepath); }
			}
		}
	}
	else
	{
		//are we trying to write?
		//say it doesn't exist if this path is read-only
		if(bWriteMode && TESTFLAGS(fsPath.flag, FS_DIR_READONLY))
			return 0;

		wstring path = fsPath.str;
		path += L"\\";
		path += filepath;

		//try to open the file
		fp->fp = _wfopen(path.c_str(), mode);

		if(fp->fp) 
		{
			//detect unicode...
			u16 magic;
			FSRead(&magic, sizeof(u16), 1, fp);

			if(magic == 0xfffe) fp->uCType = UC_BigEndian;
			else if(magic == 0xfeff) fp->uCType = UC_Base;

			if(fp->uCType != UC_None)
				_setmode( _fileno( fp->fp ), _O_BINARY );
			else
				FSSeek(fp, 0, FS_SEEK_SET);

			ret = TRUE;
		}
	}

	return ret;
}
示例#3
0
OSErr
IsFlattenedResourceFile(
	ConstFSSpecPtr	inFile,
	Boolean*		outIsFlat)
{
	OSErr		err;
	CInfoPBRec	pb;
	
	if (not inFile)
	{
		// This can occur when we create a new project document (Cmd-N)
		*outIsFlat = false;
		return noErr;
	}

	pb.hFileInfo.ioNamePtr = (StringPtr)inFile->name;
	pb.hFileInfo.ioVRefNum = inFile->vRefNum;
	pb.hFileInfo.ioDirID = inFile->parID;
	pb.hFileInfo.ioFDirIndex = 0;

	err = PBGetCatInfoSync(&pb);
	if (err == noErr)
	{
		if (pb.hFileInfo.ioFlAttrib & kioFlAttribDirMask)
		{
			// This is a directory
			*outIsFlat = false;
			return paramErr;
		}
		else
		{
			UInt32	dfSize;
			UInt32	rfSize;
			SInt16	dfRefNum;
			SInt32	filePos;
			
			dfSize = pb.hFileInfo.ioFlLgLen;
			rfSize = pb.hFileInfo.ioFlRLgLen;
			
			if (rfSize > 0)
			{
				*outIsFlat = false;
			}
			else if (dfSize == 0)
			{
				// This file has no data or resource fork.
				*outIsFlat = false;
			}
			else
			{
				// Only the data fork is non-empty.
				// Now we need to determine if it contains resources or not.
				UInt32	firstFourWords[4];
				SInt32	byteCount;
				
				err = FSpOpenDF(inFile, fsRdPerm, &dfRefNum);
				if (err)	return err;
				
				err = GetFPos(dfRefNum, &filePos);
				
				byteCount = sizeof(firstFourWords);

				err = FSRead(dfRefNum, &byteCount, &firstFourWords);
				if (err == noErr)
				{
					// Test is based on resource file format as described in IM: More Mac Toolbox
					// <http://developer.apple.com/techpubs/mac/MoreToolbox/MoreToolbox-99.html#HEADING99-0>
					//
					// First four words of the file represent the resource header
					// Word1:  Offset from beginning of resource fork to resource data
					// Word2:  Offset from beginning of resource fork to resource map
					// Word3:  Length of resource data
					// Word4:  Length of resource map
					//
					// So...
					// (Word1 + Word3 + Word4) == (Word2 + Word4) == size of resource fork

					if ((byteCount == sizeof(firstFourWords)) and
						(EndianU32_BtoN(firstFourWords[0]) + EndianU32_BtoN(firstFourWords[2]) +
						 EndianU32_BtoN(firstFourWords[3]) == dfSize) and
						(EndianU32_BtoN(firstFourWords[1]) + EndianU32_BtoN(firstFourWords[3]) == dfSize))
					{
						*outIsFlat = true;
					}
				}
				
				err = SetFPos(dfRefNum, fsFromStart, filePos);

				err = FSClose(dfRefNum);
			}
		}
	}
	
	return err;
}
示例#4
0
OSErr ReadObjectInfo (short FRefNum, ObjectRecHdl *thisObjectHdlPtr)
{
	OSErr	ErrCode = 0;
	long	byteCount, structSize;
	Handle	thisObjectHdl = nil, thisObjectDataHdl = nil;

	// read the size of this object's info handle
	byteCount = sizeof (long);
	ErrCode = FSRead (FRefNum, &byteCount, (Ptr) &structSize);
	if (!ErrCode)
	{
		thisObjectHdl = _NewHandleClear (structSize);
		if (thisObjectHdl != nil)
		{
			_HLock (thisObjectHdl);
		
			ErrCode = FSRead (FRefNum, &structSize, (Ptr) *thisObjectHdl);
		
			_HUnlock (thisObjectHdl);
		}
		else
			ErrCode = memFullErr;
	}
	
	if (!ErrCode)	// read the object's data handle if any
	{
		if (GetObjectDataHdl ((ObjectRecHdl) thisObjectHdl) != nil)
		{
			// read the size of this object's data handle
			byteCount = sizeof (long);
			ErrCode = FSRead (FRefNum, &byteCount, (Ptr) &structSize);
		
			if (!ErrCode)
			{
				thisObjectDataHdl = _NewHandleClear (structSize);
				if (thisObjectDataHdl != nil)
				{
					_HLock (thisObjectDataHdl);
				
					ErrCode = FSRead (FRefNum, &structSize, (Ptr) *thisObjectDataHdl);

					_HUnlock (thisObjectDataHdl);

					if (!ErrCode)
						SetObjectDataHdl ((ObjectRecHdl) thisObjectHdl, thisObjectDataHdl);
				}
				else
					ErrCode = memFullErr;
			}
		}
	}
	
	if (ErrCode)
	{
		if (thisObjectHdl != nil)
			DisposeHandle (thisObjectDataHdl);	

		if (thisObjectHdl != nil)
			DisposeHandle (thisObjectDataHdl);	
	}
	
	if (!ErrCode)
		*thisObjectHdlPtr = (ObjectRecHdl) thisObjectHdl;	// send this handle back
	
	return (ErrCode);
}
OSErr PAS_decodeMisc(PASEntry *entry, FSSpec *outFile, short inRefNum)
{
	OSErr 		err = noErr;	
	short		outRefNum;
	PASMiscInfo	info;
	SInt32		infoSize;
	FInfo		theFInfo;
		
	
	infoSize	=	sizeof(PASMiscInfo);
	
	err = SetFPos(inRefNum, fsFromStart, (*entry).entryOffset );
	if (err != noErr)	return err;

	err	= FSRead( inRefNum, &infoSize, &info);
	if (err != noErr)	return err;

	if(infoSize != sizeof(PASMiscInfo))
	{
		return -1;
	}

	err = FSpOpenDF(outFile, fsRdWrPerm, &outRefNum);
	if (err != noErr)	return err;
	
	memset(&theFInfo, 0, sizeof(FInfo));   
		
	theFInfo.fdType		=	info.fileType;
	theFInfo.fdCreator	=	info.fileCreator;	
	theFInfo.fdFlags	=	info.fileFlags;
	
	err = FSpSetFInfo(outFile, &theFInfo);
	if (err != noErr)	return err;
		
	FSClose(outRefNum);
	
	if (info.fileHasResFork)
	{
		outRefNum = FSpOpenResFile(outFile, fsRdWrPerm);
		if (outRefNum < noErr)
		{
			// maybe it does not have one!
			
			FSpCreateResFile(outFile, info.fileCreator, info.fileType, smSystemScript);
			
			outRefNum = FSpOpenResFile(outFile, fsRdWrPerm);	
			if (outRefNum < noErr) 
			{
				return outRefNum;
			}
		}
		
		SetResFileAttrs(outRefNum, info.fileResAttrs);
		
		
		CloseResFile(outRefNum);
	}	
	
	
	if(info.fileType == 'APPL')
	{
		// we need to add applications to the desktop database.
		
/*	FIX :: need to find DTSetAPPL() function	
		err = DTSetAPPL( NULL,
                    	 outFile->vRefNum,
			             info.fileCreator,
			             outFile->parID,
                         outFile->name);
*/	}
	
	
	return err;
	
	

}
OSErr PAS_decodeResource(PASEntry *entry, FSSpec *outFile, short inRefNum)
{
	OSErr 			err = noErr;	
	short			outRefNum;
	PASResFork		info;
	SInt32			infoSize;
	short			oldResFile;
	
	PASResource		pasRes;
	SInt32			pasResSize;
	
	long			bufSize;
	Handle			buffer;
	long			counter=0;
	
	infoSize	=	sizeof(PASResFork);
	
	err = SetFPos(inRefNum, fsFromStart, (*entry).entryOffset );
	if (err != noErr)	return err;

	err	= FSRead( inRefNum, &infoSize, &info);
	if (err != noErr)	return err;

	if(infoSize != sizeof(PASResFork))
	{
		err = -1;
		goto error;
	}
	
	oldResFile=CurResFile();
	
	outRefNum = FSpOpenResFile(outFile, fsRdWrPerm);
	if (outRefNum < noErr)	return outRefNum;
				
	UseResFile(outRefNum);
	
	
	while (1)
	{
		pasResSize	=	sizeof(PASResource);
		err	= FSRead( inRefNum, &pasResSize, &pasRes);
		
		if (err != noErr)
		{
			if(err == eofErr)
				err = noErr;
				
			break;
		}
		
		bufSize	=	pasRes.length;
		buffer	=	NewHandle(bufSize);
		HLock(buffer);
		
		if(buffer == NULL)
		{
			//  if we did not get our memory, try updateresfile 
		
			HUnlock(buffer);


			UpdateResFile(outRefNum);
			counter=0;
			
			buffer	=	NewHandle(bufSize);
			HLock(buffer);
			
			if(buffer == NULL)
			{
				err = memFullErr;
				break;
			}
		}
		
		err	= FSRead( inRefNum, &bufSize, &(**buffer));
		if (err != noErr && err != eofErr)	break;
		
		AddResource(buffer, pasRes.attrType, pasRes.attrID, pasRes.attrName);
		WriteResource(buffer);
		
		SetResAttrs(buffer, pasRes.attr);
		ChangedResource(buffer);	
		WriteResource(buffer);
		
		ReleaseResource(buffer);	
		
		if (counter++ > 100)
		{
			UpdateResFile(outRefNum);
			counter=0;
		}
	
	}

error:
		
	UseResFile(oldResFile);	
	CloseResFile(outRefNum);
		
	return err;
}
OSErr PAS_DecodeFile(FSSpec *inSpec, FSSpec *outSpec)
{
	OSErr		err;
	short		inRefNum;
	
	PASHeader	header;
	
	PASEntry 	dataEntry, miscEntry, resourceEntry;
	long		sizeOfEntry;

	if (inSpec == NULL || outSpec == NULL)
		return paramErr;
		
		
	FSpDelete( outSpec ) ;
	
	err = FSpCreate( outSpec, kCreator, kType ,smSystemScript );
	
	if (err != noErr) 	return err;
	
	
	
	err = FSpOpenDF(inSpec, fsRdPerm, &inRefNum);
	
	if (err != noErr)  goto error;

	
	// Read Header 
		
	err	= PAS_decodeHeader(inRefNum, &header);
	if (err != noErr)  goto error;
	
	if(	header.magicNum != PAS_MAGIC_NUM ||
		header.versionNum != PAS_VERSION)
	{
		err = -1;
		goto error;
	}
	
	
	
	// Read Data Entry 
	
	
	err = SetFPos(inRefNum, fsFromStart, sizeof(PASHeader));
	if (err != noErr) 	goto error;
	
	sizeOfEntry			=	sizeof(PASEntry);

	err = FSRead(inRefNum, &sizeOfEntry, &dataEntry);
	if (err != noErr) 	goto error;
	
	
	
	
	// Read Misc Entry 
	
	
	err = SetFPos(inRefNum, fsFromStart, (sizeof(PASHeader) + sizeof(PASEntry)));
	if (err != noErr) 	goto error;
	
	sizeOfEntry			=	sizeof(PASEntry);

	err = FSRead(inRefNum, &sizeOfEntry, &miscEntry);
	if (err != noErr) 	goto error;
	

	// Read Resource Entry 
	
	
	err = SetFPos(inRefNum, fsFromStart, (sizeof(PASHeader) + (2 * sizeof(PASEntry)))) ;
	if (err != noErr) 	goto error;
	
	sizeOfEntry			=	sizeof(PASEntry);

	err = FSRead(inRefNum, &sizeOfEntry, &resourceEntry);
	if (err != noErr) 	goto error;





	err =  PAS_decodeData(&dataEntry, outSpec, inRefNum);	
	if (err != noErr) 	goto error;

	err =  PAS_decodeMisc(&miscEntry, outSpec, inRefNum);
	if (err != noErr) 	goto error;

	err =  PAS_decodeResource(&resourceEntry, outSpec, inRefNum);	
	if (err == kResFileNotOpened)
	{
		// there was no resource fork
		err = noErr;
	}
	else if (err != noErr)
	{
		goto error;
	}

	
	FSClose(inRefNum);
	
	return noErr;
	
	
	
error:

	if (inRefNum != kResFileNotOpened)
	{
		FSClose(inRefNum);
	}
		
	FSpDelete( outSpec ) ;
	
	return err;
	
}
示例#8
0
void
InitLicTxt(void)
{
	Rect	destRect, viewRect;
	FSSpec	licFile;
	long 	dirID, dataSize;
	short 	vRefNum, dataRef, resRef;
	unsigned char* 	cLicFName;
	Str255			pLicFName;
	OSErr	err;
	Handle 	text, stylHdl;
	
	ERR_CHECK(GetCWD(&dirID, &vRefNum));
	
	/* open and read license file */
	HLock(gControls->cfg->licFileName);
	if(**gControls->cfg->licFileName != nil)
	{
		cLicFName = CToPascal(*gControls->cfg->licFileName);
		
		ERR_CHECK(FSMakeFSSpec(vRefNum, dirID, cLicFName, &licFile));
		if (cLicFName)
			DisposePtr((char*)cLicFName);
	}
	else /* assume default license filename from str rsrc */
	{	
		GetResourcedString(pLicFName, rInstList, sLicenseFName);
		ERR_CHECK(FSMakeFSSpec(vRefNum, dirID, pLicFName, &licFile));
	}
	HUnlock(gControls->cfg->licFileName);
	
	/* read license text */
	ERR_CHECK(FSpOpenDF( &licFile, fsRdPerm, &dataRef));
	ERR_CHECK(GetEOF(dataRef, &dataSize));

	if (dataSize > 0)
	{
		if (!(text = NewHandle(dataSize)))
		{
			ErrorHandler(eMem, nil);
			return;
		}
		ERR_CHECK(FSRead(dataRef, &dataSize, *text));
	}
	else
		text = nil;
	ERR_CHECK(FSClose(dataRef));

	/* get 'styl' if license is multistyled */
	resRef = FSpOpenResFile( &licFile, fsRdPerm);
	ERR_CHECK(ResError());

	UseResFile(resRef);
	stylHdl = RGetResource('styl', 128);
	ERR_CHECK(ResError());
	
	if(stylHdl)
		DetachResource(stylHdl);
	else
		stylHdl = nil;
	CloseResFile(resRef);
	
	/* TE specific init */
	HLock( (Handle) gControls->lw->licBox);
	SetRect(&viewRect, 	(*(gControls->lw->licBox))->contrlRect.left, 
						(*(gControls->lw->licBox))->contrlRect.top, 
						(*(gControls->lw->licBox))->contrlRect.right, 
						(*(gControls->lw->licBox))->contrlRect.bottom);
	HUnlock( (Handle) gControls->lw->licBox);

	destRect.left = viewRect.left;
		viewRect.right = (*(gControls->lw->scrollBar))->contrlRect.left; 
	destRect.right = viewRect.right;
	destRect.top = viewRect.top;
	destRect.bottom = viewRect.bottom * kNumLicScrns;
	
	// gControls->lw->licTxt = (TEHandle) NewPtrClear(sizeof(TEPtr));
	
	TextFont(applFont);
	TextFace(normal);
	TextSize(9);
	
	HLock(text);
	if (stylHdl)
	{
		gControls->lw->licTxt = TEStyleNew( &destRect, &viewRect );
		TEStyleInsert( *text, dataSize, (StScrpRec ** )stylHdl, 
						gControls->lw->licTxt);
	}
	else
	{
		gControls->lw->licTxt = TENew( &destRect, &viewRect);
		TEInsert( *text, dataSize, gControls->lw->licTxt);
	}
	HUnlock(text);
	
	TextFont(systemFont);
	TextSize(12);
	
	TESetAlignment(teFlushDefault, gControls->lw->licTxt);
}