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; }