static int file_readline(FILEH fh, char *buf, int len) {
DWORD pos;
DWORD readsize;
DWORD i;
if (len < 2) {
return(-1);
}
pos = File_Seek(fh, 0, FSEEK_CUR);
if (pos == (DWORD)-1) {
return(-1);
}
readsize = File_Read(fh, buf, len-1);
if (readsize == (DWORD)-1) {
return(-1);
}
if (!readsize) {
return(-1);
}
for (i=0; i<readsize; i++) {
pos++;
if ((buf[i] == 0x0a) || (buf[i] == 0x0d)) {
break;
}
}
buf[i] = '\0';
if (File_Seek(fh, pos, FSEEK_SET) != pos) {
return(-1);
}
return(i);
}
/** FATのフラッシュ */
void FatVol_FlushFat(C_FATVOL *self)
{
unsigned long i;
/* FAT先頭へ移動 */
File_Seek(self->hBlockFile, self->FatStartSector * self->BytesPerSector + self->Offset, FILE_SEEK_SET);
for ( i = 0; i < self->FatNum; i++ )
{
int j;
for ( j = 0; j < self->SectorPerFat; j++ )
{
if ( self->pubFatDirty[j] )
{
File_Write(self->hBlockFile, &self->pubFatBuf[j * self->BytesPerSector], (FILE_SIZE)self->BytesPerSector);
}
else
{
File_Seek(self->hBlockFile, self->BytesPerSector, FILE_SEEK_CUR);
}
}
}
/* 更新フラグクリア */
memset(self->pubFatDirty, 0, (size_t)self->SectorPerFat);
}
/*!
* \brief Load an ELF file into an address space
* \param space Address space
* \param data ELF file data
* \param size Size of data
*/
Elf::Entry Elf::load(AddressSpace *space, const char *name)
{
Elf32_Ehdr hdr;
int obj;
// World's stupidest ELF loader. Loop across program headers and
// copy each into the address space
obj = Name_Open(name);
File_Read(obj, &hdr, sizeof(hdr));
Elf32_Phdr phdrs[hdr.e_phnum];
File_Seek(obj, hdr.e_phoff);
File_Read(obj, phdrs, sizeof(phdrs));
for(int i=0; i<hdr.e_phnum; i++) {
if(phdrs[i].p_type != PT_LOAD) {
continue;
}
// Add a memory area for each program header
int aligned = PAGE_ADDR_ROUND_DOWN(phdrs[i].p_vaddr);
MemArea *area = new MemAreaPages(phdrs[i].p_memsz + phdrs[i].p_vaddr - aligned);
space->map(area, (void*)phdrs[i].p_vaddr, 0, area->size());
// Copy the data into the section, and zero-init the space at the end
File_Seek(obj, phdrs[i].p_offset);
File_Read(obj, (void*)phdrs[i].p_vaddr, phdrs[i].p_filesz);
memset((void*)(phdrs[i].p_vaddr + phdrs[i].p_filesz), 0, phdrs[i].p_memsz - phdrs[i].p_filesz);
}
Object_Release(obj);
return (Entry)hdr.e_entry;
}
/**
* Seek to the given chunk inside a chunk file.
*
* @param index The index given by ChunkFile_Open() of the file.
* @param chunk The chunk to seek to.
* @return The length of the chunk (0 if not found).
*/
uint32 ChunkFile_Seek(uint8 index, uint32 chunk)
{
uint32 value = 0;
uint32 length = 0;
bool first = true;
while (true) {
if (File_Read(index, &value, 4) != 4 && !first) return 0;
if (value == 0 && File_Read(index, &value, 4) != 4 && !first) return 0;
if (File_Read(index, &length, 4) != 4 && !first) return 0;
length = HTOBE32(length);
if (value == chunk) {
File_Seek(index, -8, 1);
return length;
}
if (first) {
File_Seek(index, 12, 0);
first = false;
continue;
}
length += 1;
length &= 0xFFFFFFFE;
File_Seek(index, length, 1);
}
}
/**
* Reads the whole file into buffer.
*
* @param filename The name of the file to open.
* @param buf The buffer to read into.
* @return The length of the file.
*/
uint32 File_ReadFile(const char *filename, void *buf)
{
uint8 index;
uint32 length;
index = File_Open(filename, 1);
length = File_Seek(index, 0, 2);
File_Seek(index, 0, 0);
File_Read(index, buf, length);
File_Close(index);
return length;
}
int D88_SetFD(int drv, char* filename)
{
int trk, sct;
FILEH fp;
D88_SECTOR d88s;
strncpy(D88File[drv], filename, MAX_PATH);
D88File[drv][MAX_PATH-1] = 0;
fp = File_Open(D88File[drv]);
if ( !fp ) {
ZeroMemory(D88File[drv], MAX_PATH);
return FALSE;
}
File_Seek(fp, 0, FSEEK_SET);
if ( File_Read(fp, &D88Head[drv], sizeof(D88_HEADER))!=sizeof(D88_HEADER) ) goto d88_set_error;
if ( D88Head[drv].protect ) {
FDD_SetReadOnly(drv);
}
for (trk=0; trk<164; trk++) {
long ptr = D88Head[drv].trackp[trk];
D88_SECTINFO *si, *oldsi = NULL;
if ( (ptr>=(long)sizeof(D88_HEADER))&&(ptr<D88Head[drv].fd_size) ) {
d88s.sectors = 65535;
File_Seek(fp, ptr, FSEEK_SET);
for (sct=0; sct<d88s.sectors; sct++) {
if ( File_Read(fp, &d88s, sizeof(D88_SECTOR))!=sizeof(D88_SECTOR) ) goto d88_set_error;
si = (D88_SECTINFO*)malloc(sizeof(D88_SECTINFO)+d88s.size);
if ( !si ) goto d88_set_error;
if ( sct ) {
oldsi->next = si;
} else {
D88Trks[drv][trk] = si;
}
memcpy(&si->sect, &d88s, sizeof(D88_SECTOR));
if ( File_Read(fp, ((unsigned char*)si)+sizeof(D88_SECTINFO), d88s.size)!=d88s.size ) goto d88_set_error;
si->next = 0;
if (oldsi) oldsi = si;
}
}
}
File_Close(fp);
return TRUE;
d88_set_error:
File_Close(fp);
FDD_SetReadOnly(drv);
return FALSE;
}
/** クラスタ書き込み */
int FatVol_ClusterWrite(
C_FATVOL *self,
FATVOL_UINT uiCluster,
const void *pBuf)
{
FATVOL_UINT uiPos;
FATVOL_UINT uiSize;
/* StdIo_PrintFormat("[FatLol] write cluster %08x\n", uiCluster); */
if ( uiCluster >= 0x0f000000 && (self->iFatType == FATVOL_TYPE_FAT12 || self->iFatType == FATVOL_TYPE_FAT16) )
{
/* FAT12/16 のルートディレクトリを 0x0f000000 にマップ */
uiCluster -= 0x0f000000;
/* 書き出し位置移動 */
uiPos = (self->RootDirSector + (uiCluster * self->SectorsPerCluster)) * self->BytesPerSector + self->Offset;
if ( File_Seek(self->hBlockFile, uiPos, FILE_SEEK_SET) != uiPos )
{
return FATVOL_ERR_NG;
}
/* 書き出し */
uiSize = self->BytesPerSector * self->SectorsPerCluster;
if ( File_Write(self->hBlockFile, pBuf, (FILE_SIZE)uiSize) != uiSize )
{
return FATVOL_ERR_NG;
}
}
else
{
/* 書き出し位置移動 */
uiPos = (self->Cluster0Sector + (uiCluster * self->SectorsPerCluster)) * self->BytesPerSector + self->Offset;
if ( File_Seek(self->hBlockFile, uiPos, FILE_SEEK_SET) != uiPos )
{
return FATVOL_ERR_NG;
}
/* 書き出し */
uiSize = self->BytesPerSector * self->SectorsPerCluster;
if ( File_Write(self->hBlockFile, pBuf, (FILE_SIZE)uiSize) != uiSize )
{
return FATVOL_ERR_NG;
}
}
return FATVOL_ERR_OK;
}
/**
* Read bytes from a chunk file into a buffer.
*
* @param index The index given by ChunkFile_Open() of the file.
* @param chunk The chunk to read from.
* @param buffer The buffer to read into.
* @param length The amount of bytes to read.
* @return The amount of bytes truly read, or 0 if there was a failure.
*/
uint32 ChunkFile_Read(uint8 index, uint32 chunk, void *buffer, uint32 buflen)
{
uint32 value = 0;
uint32 length = 0;
bool first = true;
while (true) {
if (File_Read(index, &value, 4) != 4 && !first) return 0;
if (value == 0 && File_Read(index, &value, 4) != 4 && !first) return 0;
if (File_Read(index, &length, 4) != 4 && !first) return 0;
length = HTOBE32(length);
if (value == chunk) {
buflen = min(buflen, length);
File_Read(index, buffer, buflen);
length += 1;
length &= 0xFFFFFFFE;
if (buflen < length) File_Seek(index, length - buflen, 1);
return buflen;
}
if (first) {
File_Seek(index, 12, 0);
first = false;
continue;
}
length += 1;
length &= 0xFFFFFFFE;
File_Seek(index, length, 1);
}
}
/**
* Open a chunk file (starting with FORM) for reading.
*
* @param filename The name of the file to open.
* @return An index value refering to the opened file, or FILE_INVALID.
*/
uint8 ChunkFile_Open(const char *filename)
{
uint8 index;
uint32 header;
index = File_Open(filename, 1);
File_Close(index);
index = File_Open(filename, 1);
File_Read(index, &header, 4);
if (header != HTOBE32('FORM')) {
File_Close(index);
return FILE_INVALID;
}
File_Seek(index, 4, 1);
return index;
}
static SRes FileInStream_Seek(void *pp, Int64 *pos, ESzSeek origin)
{
CFileInStream *p = (CFileInStream *)pp;
return File_Seek(&p->file, pos, origin);
}
static SRes FileInStream_Seek(const ISeekInStream *pp, Int64 *pos, ESzSeek origin)
{
CFileInStream *p = CONTAINER_FROM_VTBL(pp, CFileInStream, vt);
return File_Seek(&p->file, pos, origin);
}
static void GUI_Mentat_ShowHelp(void)
{
struct {
uint8 notused[8];
uint32 length;
} info;
uint8 *subject;
uint16 i;
bool noDesc;
uint8 fileID;
uint32 offset;
char *compressedText;
char *desc;
char *picture;
char *text;
bool loc12;
subject = s_helpSubjects;
for (i = 0; i < s_selectedHelpSubject; i++) subject = String_NextString(subject);
noDesc = (subject[5] == '0');
offset = HTOBE32(*(uint32 *)(subject + 1));
fileID = ChunkFile_Open(s_mentatFilename);
ChunkFile_Read(fileID, HTOBE32(CC_INFO), &info, 12);
ChunkFile_Close(fileID);
info.length = HTOBE32(info.length);
text = g_readBuffer;
compressedText = GFX_Screen_Get_ByIndex(SCREEN_1);
fileID = File_Open(s_mentatFilename, FILE_MODE_READ);
File_Seek(fileID, offset, 0);
File_Read(fileID, compressedText, info.length);
String_Decompress(compressedText, text);
String_TranslateSpecial(text, text);
File_Close(fileID);
while (*text != '*' && *text != '?') text++;
loc12 = (*text == '*');
*text++ = '\0';
if (noDesc) {
uint16 index;
picture = g_scenario.pictureBriefing;
desc = NULL;
text = (char *)g_readBuffer;
index = *text - 44 + g_campaignID * 4 + STR_HOUSE_HARKONNENFROM_THE_DARK_WORLD_OF_GIEDI_PRIME_THE_SAVAGE_HOUSE_HARKONNEN_HAS_SPREAD_ACROSS_THE_UNIVERSE_A_CRUEL_PEOPLE_THE_HARKONNEN_ARE_RUTHLESS_TOWARDS_BOTH_FRIEND_AND_FOE_IN_THEIR_FANATICAL_PURSUIT_OF_POWER + g_playerHouseID * 40;
strncpy(g_readBuffer, String_Get_ByIndex(index), g_readBufferSize);
} else {
picture = (char *)g_readBuffer;
desc = text;
while (*text != '\0' && *text != 0xC) text++;
if (*text != '\0') *text++ = '\0';
}
GUI_Mentat_Loop(picture, desc, text, loc12 ? 1 : 0, g_widgetMentatFirst);
GUI_Widget_MakeNormal(g_widgetMentatFirst, false);
GUI_Mentat_LoadHelpSubjects(false);
GUI_Mentat_Create_HelpScreen_Widgets();
GUI_Mentat_Draw(true);
}
void File::Seek(int offset) { if (file) File_Seek(file, offset); }
int SzExtract(const wchar_t* cSzPackFile, const wchar_t* cUnPackPath)
{
SRes res = SZ_OK;
CFileInStream archiveStream;
CLookToRead lookStream;
CSzArEx db;
ISzAlloc allocImp;
ISzAlloc allocTempImp;
const char *errorMessage = NULL;
wchar_t path[MAX_PATH * 3 + 2] = {0};
size_t pathLen = wcslen(cUnPackPath);
wcscpy_s(path,MAX_PATH * 3 + 2, cUnPackPath);
if (cUnPackPath[pathLen - 1] != '\\')
{
wcscat_s(path, L"\\");
pathLen = wcslen(path);
}
CrcGenerateTable();
allocImp.Alloc = SzAlloc;
allocImp.Free = SzFree;
allocTempImp.Alloc = SzAllocTemp;
allocTempImp.Free = SzFreeTemp;
FileInStream_CreateVTable(&archiveStream);
LookToRead_CreateVTable(&lookStream, False);
if (InFile_OpenW(&archiveStream.file, cSzPackFile) != 0)
{
errorMessage = "can not open input file";
res = SZ_ERROR_FAIL;
}
else
{
UInt64 pos = 0;
if (!FindSignature(&archiveStream.file, &pos))
res = SZ_ERROR_FAIL;
else if (File_Seek(&archiveStream.file, (Int64 *)&pos, SZ_SEEK_SET) != 0)
res = SZ_ERROR_FAIL;
if (res != 0)
errorMessage = "Can't find 7z archive";
}
if (res == SZ_OK)
{
lookStream.realStream = &archiveStream.s;
LookToRead_Init(&lookStream);
}
SzArEx_Init(&db);
if (res == SZ_OK)
{
res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp);
}
if (res == SZ_OK)
{
UInt32 executeFileIndex = (UInt32)(Int32)-1;
UInt32 minPrice = 1 << 30;
UInt32 i;
UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */
Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */
size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */
for (i = 0; i < db.db.NumFiles; i++)
{
size_t offset = 0;
size_t outSizeProcessed = 0;
const CSzFileItem *f = db.db.Files + i;
size_t len;
wchar_t *temp;
len = SzArEx_GetFileNameUtf16(&db, i, NULL);
if (len >= MAX_PATH)
{
res = SZ_ERROR_FAIL;
break;
}
temp = path + pathLen;
SzArEx_GetFileNameUtf16(&db, i, reinterpret_cast<UInt16*>(temp));
{
res = SzArEx_Extract(&db, &lookStream.s, i,
&blockIndex, &outBuffer, &outBufferSize,
&offset, &outSizeProcessed,
&allocImp, &allocTempImp);
if (res != SZ_OK)
break;
}
{
CSzFile outFile;
size_t processedSize;
size_t j;
size_t nameStartPos = 0;
for (j = 0; temp[j] != 0; j++)
{
if (temp[j] == '/')
{
temp[j] = 0;
MyCreateDir(path);
temp[j] = CHAR_PATH_SEPARATOR;
nameStartPos = j + 1;
}
}
if (f->IsDir)
{
MyCreateDir(path);
continue;
}
else
{
if (DoesFileOrDirExist(path))
{
errorMessage = "Duplicate file";
res = SZ_ERROR_FAIL;
break;
}
if (OutFile_OpenW(&outFile, path))
{
errorMessage = "Can't open output file";
res = SZ_ERROR_FAIL;
break;
}
}
processedSize = outSizeProcessed;
if (File_Write(&outFile, outBuffer + offset, &processedSize) != 0 || processedSize != outSizeProcessed)
{
errorMessage = "Can't write output file";
res = SZ_ERROR_FAIL;
}
#ifdef USE_WINDOWS_FILE
if (f->MTimeDefined)
{
FILETIME mTime;
mTime.dwLowDateTime = f->MTime.Low;
mTime.dwHighDateTime = f->MTime.High;
SetFileTime(outFile.handle, NULL, NULL, &mTime);
}
#endif
{
SRes res2 = File_Close(&outFile);
if (res != SZ_OK)
break;
if (res2 != SZ_OK)
{
res = res2;
break;
}
}
#ifdef USE_WINDOWS_FILE
if (f->AttribDefined)
SetFileAttributesW(path, f->Attrib);
#endif
}
}
IAlloc_Free(&allocImp, outBuffer);
}
SzArEx_Free(&db, &allocImp);
File_Close(&archiveStream.file);
if (res == SZ_OK)
return 0;
else
return 1;
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
#ifdef UNDER_CE
LPWSTR
#else
LPSTR
#endif
lpCmdLine, int nCmdShow)
#endif
{
CFileInStream archiveStream;
CLookToRead lookStream;
CSzArEx db;
SRes res = SZ_OK;
ISzAlloc allocImp;
ISzAlloc allocTempImp;
WCHAR sfxPath[MAX_PATH + 2];
WCHAR path[MAX_PATH * 3 + 2];
#ifndef UNDER_CE
WCHAR workCurDir[MAX_PATH + 32];
#endif
size_t pathLen;
DWORD winRes;
const wchar_t *cmdLineParams;
const char *errorMessage = NULL;
Bool useShellExecute = True;
DWORD exitCode = 0;
LoadSecurityDlls();
#ifdef _CONSOLE
SetConsoleCtrlHandler(HandlerRoutine, TRUE);
#else
UNUSED_VAR(hInstance);
UNUSED_VAR(hPrevInstance);
UNUSED_VAR(lpCmdLine);
UNUSED_VAR(nCmdShow);
#endif
CrcGenerateTable();
allocImp.Alloc = SzAlloc;
allocImp.Free = SzFree;
allocTempImp.Alloc = SzAllocTemp;
allocTempImp.Free = SzFreeTemp;
FileInStream_CreateVTable(&archiveStream);
LookToRead_CreateVTable(&lookStream, False);
winRes = GetModuleFileNameW(NULL, sfxPath, MAX_PATH);
if (winRes == 0 || winRes > MAX_PATH)
return 1;
{
cmdLineParams = GetCommandLineW();
#ifndef UNDER_CE
{
Bool quoteMode = False;
for (;; cmdLineParams++)
{
wchar_t c = *cmdLineParams;
if (c == L'\"')
quoteMode = !quoteMode;
else if (c == 0 || (c == L' ' && !quoteMode))
break;
}
}
#endif
}
{
unsigned i;
DWORD d;
winRes = GetTempPathW(MAX_PATH, path);
if (winRes == 0 || winRes > MAX_PATH)
return 1;
pathLen = wcslen(path);
d = (GetTickCount() << 12) ^ (GetCurrentThreadId() << 14) ^ GetCurrentProcessId();
for (i = 0;; i++, d += GetTickCount())
{
if (i >= 100)
{
res = SZ_ERROR_FAIL;
break;
}
wcscpy(path + pathLen, L"7z");
{
wchar_t *s = path + wcslen(path);
UInt32 value = d;
unsigned k;
for (k = 0; k < 8; k++)
{
unsigned t = value & 0xF;
value >>= 4;
s[7 - k] = (wchar_t)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
}
s[k] = '\0';
}
if (DoesFileOrDirExist(path))
continue;
if (CreateDirectoryW(path, NULL))
{
wcscat(path, WSTRING_PATH_SEPARATOR);
pathLen = wcslen(path);
break;
}
if (GetLastError() != ERROR_ALREADY_EXISTS)
{
res = SZ_ERROR_FAIL;
break;
}
}
#ifndef UNDER_CE
wcscpy(workCurDir, path);
#endif
if (res != SZ_OK)
errorMessage = "Can't create temp folder";
}
if (res != SZ_OK)
{
if (!errorMessage)
errorMessage = "Error";
PrintErrorMessage(errorMessage);
return 1;
}
if (InFile_OpenW(&archiveStream.file, sfxPath) != 0)
{
errorMessage = "can not open input file";
res = SZ_ERROR_FAIL;
}
else
{
UInt64 pos = 0;
if (!FindSignature(&archiveStream.file, &pos))
res = SZ_ERROR_FAIL;
else if (File_Seek(&archiveStream.file, (Int64 *)&pos, SZ_SEEK_SET) != 0)
res = SZ_ERROR_FAIL;
if (res != 0)
errorMessage = "Can't find 7z archive";
}
if (res == SZ_OK)
{
lookStream.realStream = &archiveStream.s;
LookToRead_Init(&lookStream);
}
SzArEx_Init(&db);
if (res == SZ_OK)
{
res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp);
}
if (res == SZ_OK)
{
UInt32 executeFileIndex = (UInt32)(Int32)-1;
UInt32 minPrice = 1 << 30;
UInt32 i;
UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */
Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */
size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */
for (i = 0; i < db.NumFiles; i++)
{
size_t offset = 0;
size_t outSizeProcessed = 0;
WCHAR *temp;
if (SzArEx_GetFileNameUtf16(&db, i, NULL) >= MAX_PATH)
{
res = SZ_ERROR_FAIL;
break;
}
temp = path + pathLen;
SzArEx_GetFileNameUtf16(&db, i, temp);
{
res = SzArEx_Extract(&db, &lookStream.s, i,
&blockIndex, &outBuffer, &outBufferSize,
&offset, &outSizeProcessed,
&allocImp, &allocTempImp);
if (res != SZ_OK)
break;
}
{
CSzFile outFile;
size_t processedSize;
size_t j;
size_t nameStartPos = 0;
for (j = 0; temp[j] != 0; j++)
{
if (temp[j] == '/')
{
temp[j] = 0;
MyCreateDir(path);
temp[j] = CHAR_PATH_SEPARATOR;
nameStartPos = j + 1;
}
}
if (SzArEx_IsDir(&db, i))
{
MyCreateDir(path);
continue;
}
else
{
unsigned extLen;
const WCHAR *name = temp + nameStartPos;
unsigned len = (unsigned)wcslen(name);
unsigned nameLen = FindExt(temp + nameStartPos, &extLen);
unsigned extPrice = FindItem(kExts, sizeof(kExts) / sizeof(kExts[0]), name + len - extLen, extLen);
unsigned namePrice = FindItem(kNames, sizeof(kNames) / sizeof(kNames[0]), name, nameLen);
unsigned price = namePrice + extPrice * 64 + (nameStartPos == 0 ? 0 : (1 << 12));
if (minPrice > price)
{
minPrice = price;
executeFileIndex = i;
useShellExecute = (extPrice != k_EXE_ExtIndex);
}
if (DoesFileOrDirExist(path))
{
errorMessage = "Duplicate file";
res = SZ_ERROR_FAIL;
break;
}
if (OutFile_OpenW(&outFile, path))
{
errorMessage = "Can't open output file";
res = SZ_ERROR_FAIL;
break;
}
}
processedSize = outSizeProcessed;
if (File_Write(&outFile, outBuffer + offset, &processedSize) != 0 || processedSize != outSizeProcessed)
{
errorMessage = "Can't write output file";
res = SZ_ERROR_FAIL;
}
#ifdef USE_WINDOWS_FILE
if (SzBitWithVals_Check(&db.MTime, i))
{
const CNtfsFileTime *t = db.MTime.Vals + i;
FILETIME mTime;
mTime.dwLowDateTime = t->Low;
mTime.dwHighDateTime = t->High;
SetFileTime(outFile.handle, NULL, NULL, &mTime);
}
#endif
{
SRes res2 = File_Close(&outFile);
if (res != SZ_OK)
break;
if (res2 != SZ_OK)
{
res = res2;
break;
}
}
#ifdef USE_WINDOWS_FILE
if (SzBitWithVals_Check(&db.Attribs, i))
SetFileAttributesW(path, db.Attribs.Vals[i]);
#endif
}
}
if (res == SZ_OK)
{
if (executeFileIndex == (UInt32)(Int32)-1)
{
errorMessage = "There is no file to execute";
res = SZ_ERROR_FAIL;
}
else
{
WCHAR *temp = path + pathLen;
UInt32 j;
SzArEx_GetFileNameUtf16(&db, executeFileIndex, temp);
for (j = 0; temp[j] != 0; j++)
if (temp[j] == '/')
temp[j] = CHAR_PATH_SEPARATOR;
}
}
IAlloc_Free(&allocImp, outBuffer);
}
SzArEx_Free(&db, &allocImp);
File_Close(&archiveStream.file);
if (res == SZ_OK)
{
HANDLE hProcess = 0;
#ifndef UNDER_CE
WCHAR oldCurDir[MAX_PATH + 2];
oldCurDir[0] = 0;
{
DWORD needLen = GetCurrentDirectory(MAX_PATH + 1, oldCurDir);
if (needLen == 0 || needLen > MAX_PATH)
oldCurDir[0] = 0;
SetCurrentDirectory(workCurDir);
}
#endif
if (useShellExecute)
{
SHELLEXECUTEINFO ei;
UINT32 executeRes;
BOOL success;
memset(&ei, 0, sizeof(ei));
ei.cbSize = sizeof(ei);
ei.lpFile = path;
ei.fMask = SEE_MASK_NOCLOSEPROCESS
#ifndef UNDER_CE
| SEE_MASK_FLAG_DDEWAIT
#endif
/* | SEE_MASK_NO_CONSOLE */
;
if (wcslen(cmdLineParams) != 0)
ei.lpParameters = cmdLineParams;
ei.nShow = SW_SHOWNORMAL; /* SW_HIDE; */
success = ShellExecuteEx(&ei);
executeRes = (UINT32)(UINT_PTR)ei.hInstApp;
if (!success || (executeRes <= 32 && executeRes != 0)) /* executeRes = 0 in Windows CE */
res = SZ_ERROR_FAIL;
else
hProcess = ei.hProcess;
}
else
{
STARTUPINFOW si;
PROCESS_INFORMATION pi;
WCHAR cmdLine[MAX_PATH * 3];
wcscpy(cmdLine, path);
wcscat(cmdLine, cmdLineParams);
memset(&si, 0, sizeof(si));
si.cb = sizeof(si);
if (CreateProcessW(NULL, cmdLine, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi) == 0)
res = SZ_ERROR_FAIL;
else
{
CloseHandle(pi.hThread);
hProcess = pi.hProcess;
}
}
if (hProcess != 0)
{
WaitForSingleObject(hProcess, INFINITE);
if (!GetExitCodeProcess(hProcess, &exitCode))
exitCode = 1;
CloseHandle(hProcess);
}
#ifndef UNDER_CE
SetCurrentDirectory(oldCurDir);
#endif
}
path[pathLen] = L'\0';
RemoveDirWithSubItems(path);
if (res == SZ_OK)
return (int)exitCode;
{
if (res == SZ_ERROR_UNSUPPORTED)
errorMessage = "Decoder doesn't support this archive";
else if (res == SZ_ERROR_MEM)
errorMessage = "Can't allocate required memory";
else if (res == SZ_ERROR_CRC)
errorMessage = "CRC error";
else
{
if (!errorMessage)
errorMessage = "ERROR";
}
if (errorMessage)
PrintErrorMessage(errorMessage);
}
return 1;
}
