void FreeInstData(InstData *idata, BOOL freepts)
{
FreeFileList(idata->instfiles, freepts);
FreeFileList(idata->extrafiles, freepts);
FreeFileList(idata->keepfiles, freepts);
FreeLinkList(idata->startmenu, freepts);
FreeLinkList(idata->desktop, freepts);
FreeServiceDetails(idata->service, freepts);
bfree(idata->product);
bfree(idata->installdir);
bfree(idata->startmenudir);
bfree(idata);
}
BOOL AddKeyFileList(HWND hwnd,void *PGPsc,void *PGPtls,FILELIST *ListHead)
{
PGPContextRef context;
PGPtlsContextRef tls;
MYSTATE *ms;
PGPError err;
err=kPGPError_NoErr;
context=(PGPContextRef)PGPsc;
tls=(PGPtlsContextRef)PGPtls;
if(IsPGPError(PGPclEvalExpired(hwnd, PGPCL_ALLEXPIRED)))
return FALSE;
ms=(MYSTATE *)malloc(sizeof(MYSTATE));
if(ms)
{
memset(ms, 0x00, sizeof(MYSTATE) );
ms->context=context;
ms->tlsContext=tls;
ms->ListHead=ListHead;
ms->Operation=MS_ADDKEYFILELIST;
if(OpenRings(hwnd,context,&(ms->KeySet)))
{
err=SCProgressDialog(hwnd,DoWorkThread,ms,
0,"Adding Keys from File(s)...",
"","",IDR_PROGAVI);
if(!(ms->FoundPGPData))
PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_NOPGPKEYSINFILE,
MB_OK|MB_ICONEXCLAMATION);
PGPFreeKeySet(ms->KeySet);
}
free(ms);
}
FreeFileList(ListHead);
if(IsPGPError(err))
return FALSE;
return TRUE;
}
char * CalculateDiscId(const char * directory) {
char * * files = GetFilesFromDirectory(directory);
char * * file_ptr = files;
char offsets[1500], temp_arr[1500];
char * str_ptr = offsets;
int total_time = 0;
int total_ofset = 2;
int som_of_digits = 0;
int number_of_tracks = 0;
while(*file_ptr != 0) {
TagLib_File * file = taglib_file_new(*file_ptr);
const TagLib_AudioProperties * audio = taglib_file_audioproperties(file);
int length = taglib_audioproperties_length(audio);
//printf("Song length: %i -- offset %i \n", length, total_ofset * 75);
int chars_printed = sprintf(str_ptr, "%i ", total_ofset * 75);
str_ptr = str_ptr + chars_printed;
som_of_digits = (SumOfDigits(total_ofset) + som_of_digits) % 255;
total_time += length;
total_ofset += length;
taglib_file_free(file);
file_ptr++;
number_of_tracks++;
}
FreeFileList(files);
/*printf("Som of digits is: %i\n", som_of_digits);
printf("Total time: %i\n", total_time);
printf("Number of tracks: %i\n", number_of_tracks);
printf("offsets: %s\n", offsets);
printf("Total disc length: %i\n", total_time + 2);*/
int total_string_length = sprintf(temp_arr, "%02x%04x%02x %i %s%i\n", som_of_digits, total_time, number_of_tracks, number_of_tracks, offsets, total_time + 2) + 1;
char * ret = (char *) malloc (sizeof(char) * total_string_length);
strcpy(ret, temp_arr);
return ret;
}
/**
Create multiple files within the Free Space.
@param FvDevice Firmware Volume Device.
@param FreeSpaceEntry Indicating in which Free Space(Cache) the multiple files will be inserted.
@param NumOfFiles Total File number to be written.
@param BufferSize The array of buffer size of each FfsBuffer.
@param ActualFileSize The array of actual file size.
@param PadSize The array of leading pad file size for each FFS File
@param FfsBuffer The array of Ffs Buffer pointer.
@param FileData The array of EFI_FV_WRITE_FILE_DATA structure,
used to get name, attributes, type, etc.
@retval EFI_SUCCESS Add the input multiple files into PAD file area.
@retval EFI_OUT_OF_RESOURCES No enough memory is allocated.
@retval other error Files can't be added into PAD file area.
**/
EFI_STATUS
FvCreateMultipleFilesInsideFreeSpace (
IN FV_DEVICE *FvDevice,
IN FREE_SPACE_ENTRY *FreeSpaceEntry,
IN UINTN NumOfFiles,
IN UINTN *BufferSize,
IN UINTN *ActualFileSize,
IN UINTN *PadSize,
IN UINT8 **FfsBuffer,
IN EFI_FV_WRITE_FILE_DATA *FileData
)
{
EFI_STATUS Status;
UINTN Index;
EFI_FFS_FILE_HEADER *PadFileHeader;
EFI_FFS_FILE_HEADER *FileHeader;
UINTN TotalSize;
LIST_ENTRY NewFileList;
FFS_FILE_LIST_ENTRY *NewFileListEntry;
UINTN Offset;
UINTN NumBytesWritten;
UINT8 *StartPos;
InitializeListHead (&NewFileList);
NewFileListEntry = NULL;
TotalSize = 0;
StartPos = FreeSpaceEntry->StartingAddress;
PadFileHeader = (EFI_FFS_FILE_HEADER *) StartPos;
FileHeader = PadFileHeader;
for (Index = 0; Index < NumOfFiles; Index++) {
if (PadSize[Index] != 0) {
FvFillPadFile (PadFileHeader, PadSize[Index]);
NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));
if (NewFileListEntry == NULL) {
FreeFileList (&NewFileList);
return EFI_OUT_OF_RESOURCES;
}
NewFileListEntry->FfsHeader = (UINT8 *) PadFileHeader;
InsertTailList (&NewFileList, &NewFileListEntry->Link);
}
FileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) PadFileHeader + PadSize[Index]);
Status = FvFillFfsFile (
FileHeader,
FfsBuffer[Index],
BufferSize[Index],
ActualFileSize[Index],
FileData[Index].NameGuid,
FileData[Index].Type,
FileData[Index].FileAttributes
);
if (EFI_ERROR (Status)) {
FreeFileList (&NewFileList);
return Status;
}
NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));
if (NewFileListEntry == NULL) {
FreeFileList (&NewFileList);
return EFI_OUT_OF_RESOURCES;
}
NewFileListEntry->FfsHeader = (UINT8 *) FileHeader;
InsertTailList (&NewFileList, &NewFileListEntry->Link);
PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FileHeader + BufferSize[Index]);
TotalSize += PadSize[Index];
TotalSize += BufferSize[Index];
}
if (FreeSpaceEntry->Length < TotalSize) {
FreeFileList (&NewFileList);
return EFI_OUT_OF_RESOURCES;
}
FvDevice->CurrentFfsFile = NewFileListEntry;
//
// Start writing to FV
//
Offset = (UINTN) (StartPos - FvDevice->CachedFv);
NumBytesWritten = TotalSize;
Status = FvcWrite (
FvDevice,
Offset,
&NumBytesWritten,
StartPos
);
if (EFI_ERROR (Status)) {
FreeFileList (&NewFileList);
FvDevice->CurrentFfsFile = NULL;
return Status;
}
FreeSpaceEntry->Length -= TotalSize;
FreeSpaceEntry->StartingAddress += TotalSize;
NewFileListEntry = (FFS_FILE_LIST_ENTRY *) (NewFileList.ForwardLink);
while (NewFileListEntry != (FFS_FILE_LIST_ENTRY *) &NewFileList) {
InsertTailList (&FvDevice->FfsFileListHeader, &NewFileListEntry->Link);
NewFileListEntry = (FFS_FILE_LIST_ENTRY *) (NewFileListEntry->Link.ForwardLink);
}
return EFI_SUCCESS;
}
/**
Create multiple files within a PAD File area.
@param FvDevice Firmware Volume Device.
@param PadFileEntry The pad file entry to be written in.
@param NumOfFiles Total File number to be written.
@param BufferSize The array of buffer size of each FfsBuffer.
@param ActualFileSize The array of actual file size.
@param PadSize The array of leading pad file size for each FFS File
@param FfsBuffer The array of Ffs Buffer pointer.
@param FileData The array of EFI_FV_WRITE_FILE_DATA structure,
used to get name, attributes, type, etc.
@retval EFI_SUCCESS Add the input multiple files into PAD file area.
@retval EFI_OUT_OF_RESOURCES No enough memory is allocated.
@retval other error Files can't be added into PAD file area.
**/
EFI_STATUS
FvCreateMultipleFilesInsidePadFile (
IN FV_DEVICE *FvDevice,
IN FFS_FILE_LIST_ENTRY *PadFileEntry,
IN UINTN NumOfFiles,
IN UINTN *BufferSize,
IN UINTN *ActualFileSize,
IN UINTN *PadSize,
IN UINT8 **FfsBuffer,
IN EFI_FV_WRITE_FILE_DATA *FileData
)
{
EFI_STATUS Status;
EFI_FFS_FILE_HEADER *OldPadFileHeader;
UINTN Index;
EFI_FFS_FILE_HEADER *PadFileHeader;
EFI_FFS_FILE_HEADER *FileHeader;
EFI_FFS_FILE_HEADER *TailPadFileHeader;
UINTN TotalSize;
UINTN PadAreaLength;
LIST_ENTRY NewFileList;
FFS_FILE_LIST_ENTRY *NewFileListEntry;
UINTN Offset;
UINTN NumBytesWritten;
UINT8 *StartPos;
FFS_FILE_LIST_ENTRY *FfsEntry;
FFS_FILE_LIST_ENTRY *NextFfsEntry;
InitializeListHead (&NewFileList);
NewFileListEntry = NULL;
OldPadFileHeader = (EFI_FFS_FILE_HEADER *) PadFileEntry->FfsHeader;
if (IS_FFS_FILE2 (OldPadFileHeader)) {
PadAreaLength = FFS_FILE2_SIZE (OldPadFileHeader) - sizeof (EFI_FFS_FILE_HEADER2);
} else {
PadAreaLength = FFS_FILE_SIZE (OldPadFileHeader) - sizeof (EFI_FFS_FILE_HEADER);
}
Status = UpdateHeaderBit (
FvDevice,
OldPadFileHeader,
EFI_FILE_MARKED_FOR_UPDATE
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Update PAD area
//
TotalSize = 0;
if (IS_FFS_FILE2 (OldPadFileHeader)) {
PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER2));
} else {
PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER));
}
FileHeader = PadFileHeader;
for (Index = 0; Index < NumOfFiles; Index++) {
if (PadSize[Index] != 0) {
FvFillPadFile (PadFileHeader, PadSize[Index]);
NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));
if (NewFileListEntry == NULL) {
FreeFileList (&NewFileList);
return EFI_OUT_OF_RESOURCES;
}
NewFileListEntry->FfsHeader = (UINT8 *) PadFileHeader;
InsertTailList (&NewFileList, &NewFileListEntry->Link);
}
FileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) PadFileHeader + PadSize[Index]);
Status = FvFillFfsFile (
FileHeader,
FfsBuffer[Index],
BufferSize[Index],
ActualFileSize[Index],
FileData[Index].NameGuid,
FileData[Index].Type,
FileData[Index].FileAttributes
);
if (EFI_ERROR (Status)) {
FreeFileList (&NewFileList);
return Status;
}
NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));
if (NewFileListEntry == NULL) {
FreeFileList (&NewFileList);
return EFI_OUT_OF_RESOURCES;
}
NewFileListEntry->FfsHeader = (UINT8 *) FileHeader;
InsertTailList (&NewFileList, &NewFileListEntry->Link);
PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FileHeader + BufferSize[Index]);
TotalSize += PadSize[Index];
TotalSize += BufferSize[Index];
}
FvDevice->CurrentFfsFile = NewFileListEntry;
//
// Maybe we need a tail pad file
//
if (PadAreaLength > TotalSize) {
if ((PadAreaLength - TotalSize) >= sizeof (EFI_FFS_FILE_HEADER)) {
//
// we can insert another PAD file
//
TailPadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FileHeader + BufferSize[NumOfFiles - 1]);
FvFillPadFile (TailPadFileHeader, PadAreaLength - TotalSize);
NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));
if (NewFileListEntry == NULL) {
FreeFileList (&NewFileList);
FvDevice->CurrentFfsFile = NULL;
return EFI_OUT_OF_RESOURCES;
}
NewFileListEntry->FfsHeader = (UINT8 *) TailPadFileHeader;
InsertTailList (&NewFileList, &NewFileListEntry->Link);
} else {
//
// because left size cannot hold another PAD file header,
// adjust the writing file size (just in cache)
//
FvAdjustFfsFile (
FvDevice->ErasePolarity,
FileHeader,
PadAreaLength - TotalSize
);
}
}
//
// Start writing to FV
//
if (IS_FFS_FILE2 (OldPadFileHeader)) {
StartPos = (UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER2);
} else {
StartPos = (UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER);
}
Offset = (UINTN) (StartPos - FvDevice->CachedFv);
NumBytesWritten = PadAreaLength;
Status = FvcWrite (
FvDevice,
Offset,
&NumBytesWritten,
StartPos
);
if (EFI_ERROR (Status)) {
FreeFileList (&NewFileList);
FvDevice->CurrentFfsFile = NULL;
return Status;
}
Status = UpdateHeaderBit (
FvDevice,
OldPadFileHeader,
EFI_FILE_HEADER_INVALID
);
if (EFI_ERROR (Status)) {
FreeFileList (&NewFileList);
FvDevice->CurrentFfsFile = NULL;
return Status;
}
//
// Update File List Link
//
//
// First delete old pad file entry
//
FfsEntry = (FFS_FILE_LIST_ENTRY *) PadFileEntry->Link.BackLink;
NextFfsEntry = (FFS_FILE_LIST_ENTRY *) PadFileEntry->Link.ForwardLink;
FreePool (PadFileEntry);
FfsEntry->Link.ForwardLink = NewFileList.ForwardLink;
(NewFileList.ForwardLink)->BackLink = &FfsEntry->Link;
NextFfsEntry->Link.BackLink = NewFileList.BackLink;
(NewFileList.BackLink)->ForwardLink = &NextFfsEntry->Link;
return EFI_SUCCESS;
}
/**
Create a new file within a PAD file area.
@param FvDevice Firmware Volume Device.
@param FfsFileBuffer A buffer that holds an FFS file,(it contains a File Header which is in init state).
@param BufferSize The size of FfsFileBuffer.
@param ActualFileSize The actual file length, it may not be multiples of 8.
@param FileName The FFS File Name.
@param FileType The FFS File Type.
@param FileAttributes The Attributes of the FFS File to be created.
@retval EFI_SUCCESS Successfully create a new file within the found PAD file area.
@retval EFI_OUT_OF_RESOURCES No suitable PAD file is found.
@retval other errors New file is created failed.
**/
EFI_STATUS
FvCreateNewFileInsidePadFile (
IN FV_DEVICE *FvDevice,
IN UINT8 *FfsFileBuffer,
IN UINTN BufferSize,
IN UINTN ActualFileSize,
IN EFI_GUID *FileName,
IN EFI_FV_FILETYPE FileType,
IN EFI_FV_FILE_ATTRIBUTES FileAttributes
)
{
UINTN RequiredAlignment;
FFS_FILE_LIST_ENTRY *PadFileEntry;
EFI_STATUS Status;
UINTN PadAreaLength;
UINTN PadSize;
EFI_FFS_FILE_HEADER *FileHeader;
EFI_FFS_FILE_HEADER *OldPadFileHeader;
EFI_FFS_FILE_HEADER *PadFileHeader;
EFI_FFS_FILE_HEADER *TailPadFileHeader;
UINTN StateOffset;
UINTN Offset;
UINTN NumBytesWritten;
UINT8 *StartPos;
LIST_ENTRY NewFileList;
FFS_FILE_LIST_ENTRY *NewFileListEntry;
FFS_FILE_LIST_ENTRY *FfsEntry;
FFS_FILE_LIST_ENTRY *NextFfsEntry;
//
// First get the required alignment from the File Attributes
//
RequiredAlignment = GetRequiredAlignment (FileAttributes);
//
// Find a suitable PAD File
//
Status = FvLocatePadFile (
FvDevice,
BufferSize,
RequiredAlignment,
&PadSize,
&PadFileEntry
);
if (EFI_ERROR (Status)) {
return EFI_OUT_OF_RESOURCES;
}
OldPadFileHeader = (EFI_FFS_FILE_HEADER *) PadFileEntry->FfsHeader;
//
// Step 1: Update Pad File Header
//
SetFileState (EFI_FILE_MARKED_FOR_UPDATE, OldPadFileHeader);
StartPos = PadFileEntry->FfsHeader;
Offset = (UINTN) (StartPos - FvDevice->CachedFv);
StateOffset = Offset + (UINT8 *) &OldPadFileHeader->State - (UINT8 *) OldPadFileHeader;
NumBytesWritten = sizeof (EFI_FFS_FILE_STATE);
Status = FvcWrite (
FvDevice,
StateOffset,
&NumBytesWritten,
&OldPadFileHeader->State
);
if (EFI_ERROR (Status)) {
SetFileState (EFI_FILE_HEADER_CONSTRUCTION, OldPadFileHeader);
return Status;
}
//
// Step 2: Update Pad area
//
InitializeListHead (&NewFileList);
if (IS_FFS_FILE2 (OldPadFileHeader)) {
PadAreaLength = FFS_FILE2_SIZE (OldPadFileHeader) - sizeof (EFI_FFS_FILE_HEADER);
PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER2));
} else {
PadAreaLength = FFS_FILE_SIZE (OldPadFileHeader) - sizeof (EFI_FFS_FILE_HEADER);
PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER));
}
if (PadSize != 0) {
//
// Insert a PAD file before to achieve required alignment
//
FvFillPadFile (PadFileHeader, PadSize);
NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));
ASSERT (NewFileListEntry != NULL);
NewFileListEntry->FfsHeader = (UINT8 *) PadFileHeader;
InsertTailList (&NewFileList, &NewFileListEntry->Link);
}
FileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) PadFileHeader + PadSize);
Status = FvFillFfsFile (
FileHeader,
FfsFileBuffer,
BufferSize,
ActualFileSize,
FileName,
FileType,
FileAttributes
);
if (EFI_ERROR (Status)) {
FreeFileList (&NewFileList);
return Status;
}
NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));
ASSERT (NewFileListEntry != NULL);
NewFileListEntry->FfsHeader = (UINT8 *) FileHeader;
InsertTailList (&NewFileList, &NewFileListEntry->Link);
FvDevice->CurrentFfsFile = NewFileListEntry;
if (PadAreaLength > (BufferSize + PadSize)) {
if ((PadAreaLength - BufferSize - PadSize) >= sizeof (EFI_FFS_FILE_HEADER)) {
//
// we can insert another PAD file
//
TailPadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FileHeader + BufferSize);
FvFillPadFile (TailPadFileHeader, PadAreaLength - BufferSize - PadSize);
NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));
ASSERT (NewFileListEntry != NULL);
NewFileListEntry->FfsHeader = (UINT8 *) TailPadFileHeader;
InsertTailList (&NewFileList, &NewFileListEntry->Link);
} else {
//
// because left size cannot hold another PAD file header,
// adjust the writing file size (just in cache)
//
FvAdjustFfsFile (
FvDevice->ErasePolarity,
FileHeader,
PadAreaLength - BufferSize - PadSize
);
}
}
//
// Start writing to FV
//
if (IS_FFS_FILE2 (OldPadFileHeader)) {
StartPos = (UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER2);
} else {
StartPos = (UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER);
}
Offset = (UINTN) (StartPos - FvDevice->CachedFv);
NumBytesWritten = PadAreaLength;
Status = FvcWrite (
FvDevice,
Offset,
&NumBytesWritten,
StartPos
);
if (EFI_ERROR (Status)) {
FreeFileList (&NewFileList);
FvDevice->CurrentFfsFile = NULL;
return Status;
}
//
// Step 3: Mark Pad file header as EFI_FILE_HEADER_INVALID
//
SetFileState (EFI_FILE_HEADER_INVALID, OldPadFileHeader);
StartPos = PadFileEntry->FfsHeader;
Offset = (UINTN) (StartPos - FvDevice->CachedFv);
StateOffset = Offset + (UINT8 *) &OldPadFileHeader->State - (UINT8 *) OldPadFileHeader;
NumBytesWritten = sizeof (EFI_FFS_FILE_STATE);
Status = FvcWrite (
FvDevice,
StateOffset,
&NumBytesWritten,
&OldPadFileHeader->State
);
if (EFI_ERROR (Status)) {
SetFileState (EFI_FILE_HEADER_INVALID, OldPadFileHeader);
FreeFileList (&NewFileList);
FvDevice->CurrentFfsFile = NULL;
return Status;
}
//
// If all successfully, update FFS_FILE_LIST
//
//
// Delete old pad file entry
//
FfsEntry = (FFS_FILE_LIST_ENTRY *) PadFileEntry->Link.BackLink;
NextFfsEntry = (FFS_FILE_LIST_ENTRY *) PadFileEntry->Link.ForwardLink;
FreePool (PadFileEntry);
FfsEntry->Link.ForwardLink = NewFileList.ForwardLink;
(NewFileList.ForwardLink)->BackLink = &FfsEntry->Link;
NextFfsEntry->Link.BackLink = NewFileList.BackLink;
(NewFileList.BackLink)->ForwardLink = &NextFfsEntry->Link;
return EFI_SUCCESS;
}
ForceInline void main2(int argc, TCHAR **argv)
{
if (argc < 2)
{
_tprintf(_T("%s input_dir\n"), findname(argv[0]));
return;
}
TCHAR szOutFile[MAX_PATH];
HANDLE hOut, hHeap;
DWORD dwLength, dwEntryCount;
PAZTYPE PazType;
TMyPAZEntry *pEntry;
hHeap = GetProcessHeap();
ghHeap = hHeap;
for (int i = 1; i != argc; ++i)
{
Char (*pPazHeader)[sizeof(headers[0])];
DWORD dwAttributes;
dwAttributes = GetFileAttributes(argv[i]);
if (dwAttributes == -1)
{
_tprintf(_T("\"%s\" doesn't exist.\n"), argv[i]);
continue;
}
else if ((dwAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
{
_tprintf(_T("%s isn't a directory.\n"), argv[i]);
continue;
}
LPCSTR lpPath;
lstrcpy(szOutFile, argv[i]);
dwLength = lstrlen(szOutFile);
if (szOutFile[dwLength - 1] == '\\')
szOutFile[dwLength - 1] = 0;
lstrcat(szOutFile, ".paz");
lpPath = argv[i];
PazType = NONE;
if (i + 2 < argc)
{
int j = i + 1;
if (argv[j][0] == '-' && ((argv[j][1] & 0xDF) == 'T'))
{
++j;
for (int k = 0; k != countof(szType); ++k)
{
if (!lstrcmpi(szType[k], argv[j]))
{
i = j;
PazType = (PAZTYPE)k;
break;
}
}
}
}
else
{
PazType = GetPazTypeFromFileName(szOutFile);
}
if (PazType == NONE)
{
_tprintf(_T("Please specify one PAZ type by -t type or use a special file name.\n")
_T("Following type is valid: \n\t")
);
for (int i = 0; i != countof(szType); ++i)
{
printf("%s ", szType[i]);
if (i == countof(szType) / 2)
printf("\n\t");
}
break;
}
dwKeyIndex = GetKeyIndex(szType[PazType], &GameInfo[dwInfoIndex]);
if (dwKeyIndex == -1)
{
printf("%s: don't know encryption key.\n", szOutFile);
continue;
}
hOut = CreateFile(szOutFile,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hOut == INVALID_HANDLE_VALUE)
{
_tprintf(_T("Can't create \"%s\"\n"), szOutFile);
continue;
}
g_bIsMovie = IsMovie(szOutFile);
bIsVoice = IsAudio(szOutFile);
SetCurrentDirectory(lpPath);
dwEntryCount = GenerateEntry(&pEntry);
if (dwEntryCount == 0 || pEntry == NULL)
{
_tprintf(_T("There is no file in \"%s\"\n"), argv[i]);
continue;
}
bNeedXor = strnicmp(szType[PazType], "pm", 2) != 0;
_tprintf(_T("Packing %s ...\n"), szOutFile);
if (bNeedXor)
{
pPazHeader = (Char (*)[32])headers[dwInfoIndex];
}
else
pPazHeader = (Char (*)[32])headers[countof(headers) - 1];
WriteFile(hOut, pPazHeader, sizeof(*pPazHeader), &dwLength, NULL);
WriteEntry(hOut, pEntry, dwEntryCount, False);
WriteFileToPaz(hOut, pEntry, dwEntryCount, PazType);
WriteEntry(hOut, pEntry, dwEntryCount, True);
// HeapFree(hHeap, 0, pEntry);
FreeFileList(pEntry);
CloseHandle(hOut);
}
}
int main(int argc, char* argv[])
{
SDAHEADER SDAHeader;
FILE *fout;
char szOutput[MAX_PATH+1];
char szDirectory[MAX_PATH+1];
FILELIST *flindex,*fl,*flnext;
GETPUTINFO gpi;
DWORD dwStubSize;
HRSRC hRCStub;
HGLOBAL hGBStub;
char *pStubData;
HMODULE hModule;
if(argc!=3)
{
printf("MakeSEA <output filename> <input directory>\n");
return 0;
}
strcpy(szOutput,argv[1]);
strcpy(szDirectory,argv[2]);
fout=fopen(szOutput,"wb");
if(fout==0)
{
printf("Could not open output file for writing\n");
return 0;
}
memset(&SDAHeader,0x00,sizeof(SDAHEADER));
memcpy(&(SDAHeader.szPGPSDA),"PGPSEA",6);
// Write out stub to disk from resources
hModule=GetModuleHandle(NULL);
hRCStub=FindResource(hModule,
MAKEINTRESOURCE(IDR_SEASTUB),
RT_RCDATA);
dwStubSize=SizeofResource(hModule,hRCStub);
hGBStub=LoadResource(hModule,hRCStub);
pStubData=(char *)LockResource(hGBStub);
fwrite(pStubData,1,dwStubSize,fout);
SDAHeader.offset=dwStubSize;
// Get files from directory parameter
fl=flindex=NULL;
AddToFileList(&flindex,szDirectory,NULL);
// Reverse list since we need directories first
while(flindex!=NULL)
{
flnext=flindex->next;
flindex->next=fl;
fl=flindex;
flindex=flnext;
}
memset(&gpi,0x00,sizeof(GETPUTINFO));
gpi.fout=fout;
gpi.SDAHeader=&SDAHeader;
gpi.fl=fl;
gpi.bFeedFilename=TRUE;
// Find beginning of SEA directory tree
gpi.PathHead=strlen(gpi.fl->name);
if(gpi.fl->name[gpi.PathHead]!='\\')
gpi.PathHead++;
gpi.fl=gpi.fl->next;
Deflate_Compress(&gpi);
FreeFileList(fl);
fwrite(&SDAHeader,1,sizeof(SDAHEADER),fout);
fclose(fout);
if(gpi.CancelOperation)
{
remove(szOutput);
}
return 0;
}
