resource.c

可用于嵌入式编程学习

		BasePtr2 = (LPBYTE)MapPtrProc(((PMODULE)hModule)->BasePtr,&ProcArray[0]);
		eptr2 = &(((PMODULE)hModule)->e32);
		if(!(pmodRes = ((PMODULE)hModule)->pmodResource))
			pmodRes = InterlockedUpdatePmodRes(&(((PMODULE)hModule)->pmodResource), hModule, BasePtr2, eptr2);
	} else {
		KSetLastError(pCurThread,ERROR_INVALID_HANDLE);
		DEBUGMSG(ZONE_ENTRY,(L"SC_FindResource exit: %8.8lx\r\n",0));
		return 0;
	}
	// If we have a MUI dll try to load from it first
	hRet = 0;
	if(pmodRes != (PMODULE)-1) {
		//DEBUGMSG(1,(L"SC_FindResource: Trying MUI %08x\r\n",pmodRes));
		DEBUGCHK(IsValidModule(pmodRes)); // at this point pmodRes is a valid PMODULE or -1
		hRet = FindResourcePart2((LPBYTE)MapPtrProc(pmodRes->BasePtr,&ProcArray[0]), &(pmodRes->e32), lpszName, lpszType);
	}
	// if no MUI or failed to find resource, try the module itself
	if(!hRet) {
		//DEBUGMSG(1,(L"SC_FindResource: Trying self\r\n"));
		hRet = FindResourcePart2(BasePtr2, eptr2, lpszName, lpszType);
	}
	if(!hRet) 
		KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
	DEBUGMSG(ZONE_ENTRY,(L"SC_FindResource exit: %8.8lx\r\n",hRet));
	return hRet;
}

// Win32 SizeofResource

DWORD SC_SizeofResource(HANDLE hModule, HANDLE hRsrc) {
	DEBUGMSG(ZONE_ENTRY,(L"SC_SizeofResource entry: %8.8lx %8.8lx\r\n",hModule,hRsrc));
	if (!hRsrc) {
		KSetLastError(pCurThread,ERROR_INVALID_HANDLE);
		DEBUGMSG(ZONE_ENTRY,(L"SC_SizeofResource exit: %8.8lx\r\n",0));
		return 0;
	}
	DEBUGMSG(ZONE_ENTRY,(L"SC_SizeofResource exit: %8.8lx\r\n",((resdata_t *)hRsrc)->size));
	return ((resdata_t *)hRsrc)->size;
}

// Win32 LoadResource

HANDLE SC_LoadResource(HANDLE hModule, HANDLE hRsrc) {
	DWORD pnum;
	PMODULE pMod;
	LPBYTE BasePtr;
	PPROCESS pProc;
	HANDLE h;
	DEBUGMSG(ZONE_ENTRY,(L"SC_LoadResource entry: %8.8lx %8.8lx\r\n",hModule,hRsrc));
	if (hModule == GetCurrentProcess())
		hModule = hCurProc;
	if (!hRsrc) {
		KSetLastError(pCurThread,ERROR_INVALID_HANDLE);
		DEBUGMSG(ZONE_ENTRY,(L"SC_LoadResource exit: %8.8lx\r\n",0));
		return 0;
	}
	if (!hModule) {
		pnum = ((DWORD)hRsrc >> VA_SECTION);
		if (pnum-- && ProcArray[pnum].dwVMBase) {
			if (!pnum) {
				EnterCriticalSection(&ModListcs);
				pMod = pModList;
				pnum = ZeroPtr(hRsrc);
				for (pMod = pModList; pMod; pMod = pMod->pMod)
					if ((pnum >= ZeroPtr(pMod->BasePtr)) && (pnum < ZeroPtr(pMod->BasePtr)+pMod->e32.e32_vsize))
						break;
				LeaveCriticalSection(&ModListcs);
				if (!pMod) {
					KSetLastError(pCurThread,ERROR_INVALID_HANDLE);
					DEBUGMSG(ZONE_ENTRY,(L"SC_LoadResource exit: %8.8lx\r\n",0));
					return 0;
				}
				BasePtr = MapPtrProc(pMod->BasePtr,&ProcArray[0]);
			} else
				BasePtr = MapPtrProc(ProcArray[pnum].BasePtr,&ProcArray[pnum]);
		} else {
			KSetLastError(pCurThread,ERROR_INVALID_HANDLE);
			DEBUGMSG(ZONE_ENTRY,(L"SC_LoadResource exit: %8.8lx\r\n",0));
			return 0;
		}
		pMod = 0;
	} else if (pProc = HandleToProc(hModule)) { // a process
		pMod = pProc->pmodResource;
		BasePtr = (LPBYTE)MapPtrProc(pProc->BasePtr,pProc);
	} else if (IsValidModule((LPMODULE)hModule)) { // a module
		pMod = ((PMODULE)hModule)->pmodResource;
		BasePtr = (LPBYTE)MapPtrProc(((PMODULE)hModule)->BasePtr,&ProcArray[0]);
	} else {
		KSetLastError(pCurThread,ERROR_INVALID_HANDLE);
		DEBUGMSG(ZONE_ENTRY,(L"SC_LoadResource exit: %8.8lx\r\n",0));
		return 0;
	}
	// check if it came out of the MUI resource dll
	if( pMod && (pMod != (PMODULE)-1) && 
		(ZeroPtr(hRsrc) >= ZeroPtr(pMod->BasePtr)) && 
		(ZeroPtr(hRsrc) < ZeroPtr(pMod->BasePtr)+pMod->e32.e32_vsize) )
			BasePtr = (LPBYTE)MapPtrProc(pMod->BasePtr,&ProcArray[0]);
	
	DEBUGMSG(ZONE_ENTRY,(L"SC_LoadResource exit: %8.8lx\r\n",BasePtr + ((resdata_t *)hRsrc)->rva));
	__try {
		h = (HANDLE)(BasePtr + ((resdata_t *)hRsrc)->rva);
	} __except(1) {
		h = 0;
		SetLastError(ERROR_INVALID_ADDRESS);
	}
	return h;
}

DWORD Decompress(LPBYTE BufIn, DWORD InSize, LPBYTE BufOut, DWORD OutSize, DWORD skip);

#pragma pack(2)
typedef struct {
	WORD idReserved;
	WORD idType;
	WORD idCount;
} ICONHEADER;

typedef struct ResourceDirectory {
	BYTE bWidth;
	BYTE bHeight;
	BYTE bColorCount;
	BYTE bReserved;
	WORD wPlanes;
	WORD wBitCount;
	DWORD dwBytesInRes;
	WORD wOrdinal;	   /* points to an RT_ICON resource */
} RESDIR;

typedef struct {
	ICONHEADER ih;
	RESDIR rgdir[1];  /* may really be > 1 */
} HEADER_AND_DIR, *PHEADER_AND_DIR;

LPBYTE OpenResourceFile(LPCWSTR lpszFile, BOOL *pInRom, DWORD *o32rva) {
	openexe_t oe;
	e32_lite e32l;
	o32_obj o32;
	o32_rom *o32rp;
	LPBYTE lpres;
	DWORD bytesread, loop;
	BOOL bRet;
	CALLBACKINFO cbi;
	OEinfo_t OEinfo;
	*pInRom = 0;
	__try {
		cbi.hProc = ProcArray[0].hProc;
		cbi.pfn = (FARPROC)SafeOpenExe;
		cbi.pvArg0 = MapPtr(lpszFile);
		bRet = PerformCallBack(&cbi,MapPtr(&oe),0,0,&OEinfo);
	} __except(EXCEPTION_EXECUTE_HANDLER) {
		bRet = FALSE;
	}
	if (!bRet) {
		KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
		DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",0));
		return 0;
	}
	if (LoadE32(&oe,&e32l,0,0,1,1,0)) {
		CloseExe(&oe);
		KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
		DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",0));
		return 0;
	}
	if (!e32l.e32_unit[RES].rva) {
		CloseExe(&oe);
		KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
		DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",0));
		return 0;
	}
	if (oe.filetype == FT_PPFSFILE) {
		for (loop = 0; loop < e32l.e32_objcnt; loop++) {
			rlseek(oe.hppfs,oe.offset+sizeof(e32_exe)+loop*sizeof(o32_obj),0);
			rread(oe.hppfs,(LPBYTE)&o32,sizeof(o32_obj));
			if (o32.o32_rva == e32l.e32_unit[RES].rva)
				break;
		}
		if (loop == e32l.e32_objcnt) {
			CloseExe(&oe);
			KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
			DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",0));
			return 0;
		}
		if (!(lpres = (LPBYTE)LocalAlloc(LMEM_FIXED,o32.o32_vsize))) {
			CloseExe(&oe);
			KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
			DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",0));
			return 0;
		}
		rlseek(oe.hppfs,o32.o32_dataptr,0);
		rread(oe.hppfs,lpres,min(o32.o32_psize,o32.o32_vsize));
		*o32rva = o32.o32_rva;
	} else if (oe.filetype == FT_OBJSTORE) {
		for (loop = 0; loop < e32l.e32_objcnt; loop++) {
			SetFilePointer(oe.hf,oe.offset+sizeof(e32_exe)+loop*sizeof(o32_obj),0,FILE_BEGIN);
			ReadFile(oe.hf,(LPBYTE)&o32,sizeof(o32_obj),&bytesread,0);
			if (o32.o32_rva == e32l.e32_unit[RES].rva)
				break;
		}
		if (loop == e32l.e32_objcnt) {
			CloseExe(&oe);
			KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
			DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",0));
			return 0;
		}
		if (!(lpres = (LPBYTE)LocalAlloc(LMEM_FIXED,o32.o32_vsize))) {
			CloseExe(&oe);
			KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
			DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",0));
			return 0;
		}
		SetFilePointer(oe.hf,o32.o32_dataptr,0,FILE_BEGIN);
		ReadFile(oe.hf,lpres,min(o32.o32_psize,o32.o32_vsize),&bytesread,0);
		*o32rva = o32.o32_rva;
	} else {
		for (loop = 0; loop < e32l.e32_objcnt; loop++) {
			o32rp = (o32_rom *)(oe.tocptr->ulO32Offset+loop*sizeof(o32_rom));
			if (o32rp->o32_rva == e32l.e32_unit[RES].rva)
				break;
		}
		if (loop == e32l.e32_objcnt) {
			CloseExe(&oe);
			KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
			DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",0));
			return 0;
		}
		if (o32rp->o32_psize) {
			if (o32rp->o32_flags & IMAGE_SCN_COMPRESSED) {
				if (!(lpres = (LPBYTE)LocalAlloc(LMEM_FIXED,o32rp->o32_vsize))) {
					CloseExe(&oe);
					KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
					DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",0));
					return 0;
				}
				bytesread = Decompress((LPVOID)(o32rp->o32_dataptr),o32rp->o32_psize,lpres,o32rp->o32_vsize,0);
				if (bytesread < o32rp->o32_vsize)
					memset(lpres+bytesread,0,o32rp->o32_vsize-bytesread);
			} else {
				lpres = (LPVOID)(o32rp->o32_dataptr);
				*pInRom = 1;
			}
		}
		*o32rva = o32rp->o32_rva;
	}
	CloseExe(&oe);
	return lpres;
}

LPVOID ExtractOneResource(LPBYTE lpres, LPCWSTR lpszName, LPCWSTR lpszType, DWORD o32rva, LPDWORD pdwSize) {
	LPBYTE lpres2;
	DWORD trva;
	if (!(trva = FindType(lpres, lpres, (LPWSTR)lpszType)) ||
	   !(trva = FindType(lpres, lpres+(trva&0x7fffffff),(LPWSTR)lpszName)) ||
	   !(trva = FindFirst(lpres+(trva&0x7fffffff))) ||
	   (trva & 0x80000000)) {
		KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
		return 0;
	}
	trva = (ULONG)(lpres + trva);
	if (!(lpres2 = (LPBYTE)LocalAlloc(LMEM_FIXED,((resdata_t *)trva)->size))) {
		KSetLastError(pCurThread,ERROR_RESOURCE_NAME_NOT_FOUND);
		return 0;
	}
	

	if (pdwSize)
		*pdwSize = ((resdata_t *)trva)->size;
	memcpy(lpres2,lpres+((resdata_t *)trva)->rva-o32rva,((resdata_t *)trva)->size);
	return lpres2;
}

LPVOID SC_ExtractResource(LPCWSTR lpszFile, LPCWSTR lpszName, LPCWSTR lpszType) {
	LPBYTE lpres, lpres2;
	BOOL inRom;
	DWORD o32rva;
	DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource entry: %8.8lx %8.8lx %8.8lx\r\n",lpszFile,lpszName,lpszType));
	if (!(lpres = OpenResourceFile(lpszFile, &inRom, &o32rva))) {
		DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",0));
		return 0;
	}
	lpres2 = ExtractOneResource(lpres,lpszName,lpszType,o32rva,0);
	if (!inRom)
		LocalFree(lpres);
	DEBUGMSG(ZONE_ENTRY,(L"SC_ExtractResource exit: %8.8lx\r\n",lpres2));
	return lpres2;
}

typedef void (* KEICB_t)(LPVOID, PHEADER_AND_DIR,PWORD);

UINT SC_KernExtractIcons(LPCWSTR lpszFile, int nIconIndex, LPBYTE *pIconLarge, LPBYTE *pIconSmall, CALLBACKINFO *pcbi) {
	LPBYTE lpres;
	BOOL inRom;
	UINT nRet = 0;
	PHEADER_AND_DIR phd;
	DWORD o32rva;
	WORD index[2];
	if (!(lpres = OpenResourceFile(lpszFile, &inRom, &o32rva)))
		return 0;
	if (phd = (PHEADER_AND_DIR)ExtractOneResource(lpres, MAKEINTRESOURCE(nIconIndex), RT_GROUP_ICON, o32rva,0)) {
		if (phd->ih.idCount) {
			((KEICB_t)pcbi->pfn)(pcbi->pvArg0,phd,index);
			if (pIconLarge && (*pIconLarge = ExtractOneResource(lpres, MAKEINTRESOURCE(phd->rgdir[index[0]].wOrdinal), RT_ICON, o32rva,0)))
				nRet++;
			if (pIconSmall && (*pIconSmall = ExtractOneResource(lpres, MAKEINTRESOURCE(phd->rgdir[index[1]].wOrdinal), RT_ICON, o32rva,0)))
				nRet++;
		}
		LocalFree(phd);
	}
	if (!inRom)
		LocalFree(lpres);
	return nRet;
}

BOOL SC_VerQueryValueW(VERBLOCK *pBlock, LPWSTR lpSubBlock, LPVOID *lplpBuffer, PUINT puLen) {
	LPWSTR lpSubBlockOrg, lpEndBlock, lpEndSubBlock, lpStart;
	WCHAR cEndBlock, cTemp;
	BOOL bString;
	DWORD dwTotBlockLen, dwHeadLen;
	int nCmp;
	*puLen = 0;
	if ((int)pBlock->wTotLen < sizeof(VERBLOCK)) {
		KSetLastError(pCurThread,ERROR_INVALID_DATA);
		return FALSE;
	}
	if (!(lpSubBlockOrg = (LPWSTR)LocalAlloc(LPTR,(strlenW(lpSubBlock)+1)*sizeof(WCHAR)))) {
		KSetLastError(pCurThread,ERROR_NOT_ENOUGH_MEMORY);
		return FALSE;
	}
	kstrcpyW(lpSubBlockOrg,lpSubBlock);
	lpSubBlock = lpSubBlockOrg;
	lpEndBlock = (LPWSTR)((LPBYTE)pBlock + pBlock->wTotLen - sizeof(WCHAR));
	cEndBlock = *lpEndBlock;
	*lpEndBlock = 0;
	bString = FALSE;
	while (*lpSubBlock) {
		while (*lpSubBlock == L'\\')
			++lpSubBlock;
		if (*lpSubBlock) {
			dwTotBlockLen = (DWORD)((LPSTR)lpEndBlock - (LPSTR)pBlock + sizeof(WCHAR));
			if (((int)dwTotBlockLen < sizeof(VERBLOCK)) || (pBlock->wTotLen > (WORD)dwTotBlockLen))
				goto NotFound;
			dwHeadLen = DWORDUP(sizeof(VERBLOCK) - sizeof(WCHAR) + (strlenW(pBlock->szKey) + 1) * sizeof(WCHAR)) + DWORDUP(pBlock->wValLen);
			if (dwHeadLen > pBlock->wTotLen)
				goto NotFound;
			lpEndSubBlock = (LPWSTR)((LPBYTE)pBlock + pBlock->wTotLen);
			pBlock = (VERBLOCK*)((LPBYTE)pBlock+dwHeadLen);
			for (lpStart=lpSubBlock; *lpSubBlock && (*lpSubBlock!=L'\\'); lpSubBlock++)
				;
			cTemp = *lpSubBlock;