WebSVN – filter_foundry – Diff – /trunk/3264_mixer/foundry_3264_mixer.cpp

 #include <windows.h>
 #include <string>
 #include <fstream>
 #include <vector>
-bool update_pe_timestamp(LPCTSTR filename, time_t timestamp) {
+typedef struct _PE32 {
-        size_t peoffset;
+        uint32_t magic; // 0x50450000
+        IMAGE_FILE_HEADER fileHeader; // COFF Header without Signature
+        IMAGE_OPTIONAL_HEADER32 optHeader; // Standard COFF fields, Windows Specific Fields, Data Directories
-        FILE* fptr;
+} PE32;
+#ifdef UNICODE
-        fptr = _wfopen(filename, L"rb+");
+typedef std::wstring tstring;
+#else
-        if (fptr == NULL) return false;
+typedef std::string tstring;
+#endif
-        fseek(fptr, 0x3C, SEEK_SET);
+int binary_file_string_replace(tstring file_name, const char* asearch, const char* areplace) {
-        fread(&peoffset, sizeof(peoffset), 1, fptr);
+        std::ifstream input(file_name, std::ios::binary);
+        std::vector<char> buffer((std::istreambuf_iterator<char>(input)), (std::istreambuf_iterator<char>()));
-        fseek(fptr, (long)peoffset + 8, SEEK_SET);
+        std::vector<char>::iterator itbegin = buffer.begin();
-        fwrite(&timestamp, sizeof(time_t), 1, fptr);
+        std::vector<char>::iterator itend = buffer.end();
+        if (strlen(asearch) != strlen(areplace)) {
+                printf("Replace value length greater than original!\n");
-        fclose(fptr);
+                return -1;
+        }
+        int MAX_BUFFER = strlen(asearch);
+        char* needed_str = (char*)malloc(MAX_BUFFER);
+        if (needed_str == 0) return -1;
+        char* replace_str = (char*)malloc(MAX_BUFFER);
+        if (replace_str == 0) return -1;
+        memcpy(needed_str, asearch, MAX_BUFFER);
+        memcpy(replace_str, areplace, MAX_BUFFER);
-        return true;
+        int ifound = 0;
+        for (auto it = itbegin; it < itend; it++) {
+                if (memcmp(it._Ptr, needed_str, MAX_BUFFER) == 0) {
+                        strncpy(it._Ptr, replace_str, MAX_BUFFER);
+                        it += MAX_BUFFER - 1; // -1 because it++ will be set on the next loop
+                        ifound++;
+                }
+        }
+        if (ifound > 0) {
-bool update_pe_stackSizeCommit(LPCTSTR filename, size_t stackReserve, size_t stackCommit) {
+                std::ofstream ofile(file_name, std::ios::out | std::ios::binary);
+                ofile.write((char*)&buffer[0], buffer.size() * sizeof(char));
-        size_t peoffset;
+                ofile.close();
-        FILE* fptr;
+        }
-        fptr = _wfopen(filename, L"rb+");
-        if (fptr == NULL) return false;
+        return ifound;
+}
-        fseek(fptr, 0x3C, SEEK_SET);
+int binary_file_string_find(tstring file_name, const char* asearch) {
-        fread(&peoffset, sizeof(peoffset), 1, fptr);
+        std::ifstream input(file_name, std::ios::binary);
+        std::vector<char> buffer((std::istreambuf_iterator<char>(input)), (std::istreambuf_iterator<char>()));
-        fseek(fptr, (long)peoffset + 12 * 8, SEEK_SET);
+        std::vector<char>::iterator itbegin = buffer.begin();
-        fwrite(&stackReserve, sizeof(size_t), 1, fptr);
+        std::vector<char>::iterator itend = buffer.end();
-        fseek(fptr, (long)peoffset + 12 * 8 + 4, SEEK_SET);
-        fwrite(&stackCommit, sizeof(size_t), 1, fptr);
+        int MAX_BUFFER = strlen(asearch);
+        char* needed_str = (char*)malloc(MAX_BUFFER);
-        fclose(fptr);
+        if (needed_str == 0) return -1;
+        memcpy(needed_str, asearch, MAX_BUFFER);
+        int ifound = 0;
+        for (auto it = itbegin; it < itend; it++) {
+                if (memcmp(it._Ptr, needed_str, MAX_BUFFER) == 0) {
+                        it += MAX_BUFFER - 1; // -1 because it++ will be set on the next loop
+                        ifound++;
+                }
+        }
-        return true;
+        return ifound;
+}
-bool update_pe_heapSizeCommit(LPCTSTR filename, size_t heapReserve, size_t heapCommit) {
+void _set_pe_int32(FILE* fptr, size_t fieldoffset, int32_t val) {
         size_t peoffset;
-        FILE* fptr;
+        fseek(fptr, 0x3C, SEEK_SET);
+        fread(&peoffset, sizeof(peoffset), 1, fptr);
-        fptr = _wfopen(filename, L"rb+");
+        fseek(fptr, (long)peoffset + fieldoffset, SEEK_SET);
-        if (fptr == NULL) return false;
+        fwrite(&val, sizeof(int32_t), 1, fptr);
+}
+int32_t _get_pe_int32(FILE* fptr, size_t fieldoffset) {
+        size_t peoffset;
+        int32_t res;
         fseek(fptr, 0x3C, SEEK_SET);
         fread(&peoffset, sizeof(peoffset), 1, fptr);
-        fseek(fptr, (long)peoffset + 13 * 8, SEEK_SET);
+        fseek(fptr, (long)peoffset + fieldoffset, SEEK_SET);
-        fwrite(&heapReserve, sizeof(size_t), 1, fptr);
+        fread(&res, sizeof(int32_t), 1, fptr);
+        return res;
+}
+bool update_pe_timestamp(LPCTSTR filename, __time32_t timestamp) {
-        fseek(fptr, (long)peoffset + 13 * 8 + 4, SEEK_SET);
+        FILE* fptr = _wfopen(filename, L"rb+");
-        fwrite(&heapCommit, sizeof(size_t), 1, fptr);
+        if (fptr == NULL) return false;
+        _set_pe_int32(fptr, /*0x0008*/offsetof(PE32, fileHeader.TimeDateStamp), timestamp);
         fclose(fptr);
         return true;
+}
+bool openWatcomCosmetics(LPCTSTR filename) {
+        if (binary_file_string_find(filename, "Open Watcom") > 0) {
+                FILE* fptr = _wfopen(filename, L"rb+");
+                if (fptr == NULL) return false;
-//DOS .EXE header
-struct image_dos_header
-{
-        uint16_t e_magic;                     // Magic number
-        uint16_t e_cblp;                      // Bytes on last page of file
+                // Min OS Version 1.11 ... But the actual minimal Windows version is Windows NT 3.11
-        uint16_t e_cp;                        // Pages in file
+                int32_t minOsVersion = _get_pe_int32(fptr, /*0x0040*/offsetof(PE32, optHeader.MajorOperatingSystemVersion));
-        uint16_t e_crlc;                      // Relocations
+                if (minOsVersion == 0x000B0001) {
-        uint16_t e_cparhdr;                   // Size of header in paragraphs
+                        _set_pe_int32(fptr, /*0x0040*/offsetof(PE32, optHeader.MajorOperatingSystemVersion), 0x00000003); // Windows 3.0
+                }
-        uint16_t e_minalloc;                  // Minimum extra paragraphs needed
+                // Stack reserved cannot be changed with linker option "OPTION STACK=1m" (Rejected https://github.com/open-watcom/open-watcom-v2/issues/780)
-        uint16_t e_maxalloc;                  // Maximum extra paragraphs needed
+                // It is not required for DLLs, but everybody does it, and I think it is cosmetics to fill these fields, even if not required.
-        uint16_t e_ss;                        // Initial (relative) SS value
+                _set_pe_int32(fptr, /*0x0060*/offsetof(PE32, optHeader.SizeOfStackReserve), 0x00100000);
-        uint16_t e_sp;                        // Initial SP value
+                _set_pe_int32(fptr, /*0x0064*/offsetof(PE32, optHeader.SizeOfStackCommit),  0x00001000);
-        uint16_t e_csum;                      // Checksum
-        uint16_t e_ip;                        // Initial IP value
+                // Heap reserved can be changed with linker option "OPTION HEAP=1m"
-        uint16_t e_cs;                        // Initial (relative) CS value
+                _set_pe_int32(fptr, /*0x0068*/offsetof(PE32, optHeader.SizeOfHeapReserve),  0x00100000);
-        uint16_t e_lfarlc;                    // File address of relocation table
+                _set_pe_int32(fptr, /*0x006C*/offsetof(PE32, optHeader.SizeOfHeapCommit),   0x00001000);
-        uint16_t e_ovno;                      // Overlay number
-        uint16_t e_res[4];                    // Reserved words
+                fclose(fptr);
-        uint16_t e_oemid;                     // OEM identifier (for e_oeminfo)
-        uint16_t e_oeminfo;                   // OEM information; e_oemid specific
+                // 32 bit (OpenWatcom cosmetics): Export table name "FilterFoundry.dll" => "FilterFoundry.8bf"
-        uint16_t e_res2[10];                  // Reserved words
+                // since OpenWatcom cannot link a 8BF file natively.
-        int32_t  e_lfanew;                    // File address of new exe header
+                binary_file_string_replace(filename, "FilterFoundry.dll", "FilterFoundry.8bf");
-};
+        }
-struct image_file_header
-{
-        uint16_t Machine;
+        return true;
-        uint16_t NumberOfSections;
-        uint32_t TimeDateStamp;
-        uint32_t PointerToSymbolTable;
-        uint32_t NumberOfSymbols;
-        uint16_t SizeOfOptionalHeader;
-        uint16_t Characteristics;
-};
+}
 uint32_t calculate_checksum(LPCTSTR filename) {
         //Calculate checksum of image
         // Taken from "PE Bliss" Cross-Platform Portable Executable C++ Library
         // https://github.com/mrexodia/portable-executable-library/blob/master/pe_lib/pe_checksum.cpp
         // Converted from C++ to C by Daniel Marschall
         FILE* fptr;
         unsigned long long checksum = 0;
-        struct image_dos_header header;
+        IMAGE_DOS_HEADER header;
         size_t filesize;
         unsigned long long top;
         unsigned long pe_checksum_pos;
         static const unsigned long checksum_pos_in_optional_headers = 64;
         size_t i;
         fptr = _wfopen(filename, L"rb");
         if (fptr == NULL) return 0x00000000;
         //Read DOS header
         fseek(fptr, 0, SEEK_SET);
-        fread(&header, sizeof(struct image_dos_header), 1, fptr);
+        fread(&header, sizeof(IMAGE_DOS_HEADER), 1, fptr);
         //Calculate PE checksum
         fseek(fptr, 0, SEEK_SET);
         top = 0xFFFFFFFF;
         top++;
         //"CheckSum" field position in optional PE headers - it's always 64 for PE and PE+
         //Calculate real PE headers "CheckSum" field position
         //Sum is safe here
-        pe_checksum_pos = header.e_lfanew + sizeof(struct image_file_header) + sizeof(uint32_t) + checksum_pos_in_optional_headers;
+        pe_checksum_pos = header.e_lfanew + sizeof(IMAGE_FILE_HEADER) + sizeof(uint32_t) + checksum_pos_in_optional_headers;
         //Calculate checksum for each byte of file
         fseek(fptr, 0L, SEEK_END);
         filesize = ftell(fptr);
         fseek(fptr, 0L, SEEK_SET);
         //Return checksum
         return (uint32_t)checksum;
+}
 bool repair_pe_checksum(LPCTSTR filename) {
-        size_t peoffset;
         FILE* fptr;
         uint32_t checksum = calculate_checksum(filename);
         //if (checksum == 0x00000000) return false;
         fptr = _wfopen(filename, L"rb+");
         if (fptr == NULL) return false;
-        fseek(fptr, 0x3C, SEEK_SET);
-        fread(&peoffset, sizeof(peoffset), 1, fptr);
-        fseek(fptr, (long)peoffset + 88, SEEK_SET);
+        _set_pe_int32(fptr, /*0x0058*/offsetof(PE32, optHeader.CheckSum), (int32_t)checksum);
-        fwrite(&checksum, sizeof(uint32_t), 1, fptr);
         fclose(fptr);
         return true;
+}
+        }
         return bSuccessful;
+}
-#ifdef UNICODE
-int binary_file_string_replace(std::wstring file_name, const char* asearch, const char* areplace) {
-#else
-int binary_file_string_replace(std::string file_name, const char* asearch, const char* areplace) {
-#endif
-        std::ifstream input(file_name, std::ios::binary);
-        std::vector<char> buffer((std::istreambuf_iterator<char>(input)), (std::istreambuf_iterator<char>()));
-        std::vector<char>::iterator itbegin = buffer.begin();
-        std::vector<char>::iterator itend = buffer.end();
-        if (strlen(asearch) != strlen(areplace)) {
-                printf("Replace value length greater than original!\n");
-                return -1;
-        }
-        int MAX_BUFFER = strlen(asearch);
-        char* needed_str = (char*)malloc(MAX_BUFFER);
-        if (needed_str == 0) return -1;
-        char* replace_str = (char*)malloc(MAX_BUFFER);
-        if (replace_str == 0) return -1;
-        memcpy(needed_str, asearch, MAX_BUFFER);
-        memcpy(replace_str, areplace, MAX_BUFFER);
-        int ifound = 0;
-        for (auto it = itbegin; it < itend ; it++) {
-                if (memcmp(it._Ptr, needed_str, MAX_BUFFER) == 0) {
-                        strncpy(it._Ptr, replace_str, MAX_BUFFER);
-                        it += MAX_BUFFER - 1; // -1 because it++ will be set on the next loop
-                        ifound++;
-                }
-        }
-        if (ifound > 0) {
-                std::ofstream ofile(file_name, std::ios::out | std::ios::binary);
-                ofile.write((char*)&buffer[0], buffer.size() * sizeof(char));
-                ofile.close();
-        }
-        return ifound;
-}
 int main()
+{
         LPCTSTR lpTemplateType = L"TPLT";
         LPCTSTR lpName32Plugin = (LPCTSTR)1032;
                 removeFromFile(file32tmp, lpTemplateType, lpName64Pipl, wLanguageNeutral);
                 removeFromFile(file64tmp, lpTemplateType, lpName32Pipl, wLanguageNeutral);
                 removeFromFile(file64tmp, lpTemplateType, lpName64Pipl, wLanguageNeutral);
+        }
-        // 32 bit (OpenWatcom cosmetics): Export table name "filterfoundry.dll" => "FilterFoundry.8bf"
-        // since OpenWatcom cannot link a 8BF file natively.
+        // Do some cosmetics to OpenWatcom binaries
-        binary_file_string_replace(file32tmp, "filterfoundry.dll", "FilterFoundry.8bf");
-        binary_file_string_replace(file32out, "filterfoundry.dll", "FilterFoundry.8bf");
-        // More OpenWatcom cosmetics! https://github.com/open-watcom/open-watcom-v2/issues/780 (Rejected)
-        // Stack reserved cannot be changed with linker option "OPTION STACK=1m" (Rejected)
-        // It is not required for DLLs, but everybody does it, and I think it is cosmetics to fill these fields, even if not required.
-        update_pe_stackSizeCommit(file32tmp, 1024 * 1024, 4096);
+        openWatcomCosmetics(file32tmp);
-        update_pe_stackSizeCommit(file32out, 1024 * 1024, 4096);
+        openWatcomCosmetics(file32out);
-        // Heap reserved can be changed with linker option "OPTION HEAP=1m"
-        update_pe_heapSizeCommit(file32tmp, 1024 * 1024, 4096);
-        update_pe_heapSizeCommit(file32out, 1024 * 1024, 4096);
         // 3. Update timestamp of 32/64 "TMP"
+        {
-                if (!update_pe_timestamp(file32tmp, time(0))) {
+                if (!update_pe_timestamp(file32tmp, (__time32_t)time(0))) {
                         DeleteFile(file32out);
                         DeleteFile(file64out);
                         printf("Error: Update TMP timestamp 32\n");
                         return 1;
+                }
-                if (!update_pe_timestamp(file64tmp, time(0))) {
+                if (!update_pe_timestamp(file64tmp, (__time32_t)time(0))) {
                         DeleteFile(file32out);
                         DeleteFile(file64out);
                         printf("Error: Update TMP timestamp 64\n");
                         return 1;
+                }
                 DeleteFile(file64tmp);
+        }
         // 9. Update timestamp of 32/64 "OUT"
+        {
-                if (!update_pe_timestamp(file32out, time(0))) {
+                if (!update_pe_timestamp(file32out, (__time32_t)time(0))) {
                         DeleteFile(file32out);
                         DeleteFile(file64out);
                         printf("Error: Update OUT timestamp 32\n");
                         return 1;
+                }
-                if (!update_pe_timestamp(file64out, time(0))) {
+                if (!update_pe_timestamp(file64out, (__time32_t)time(0))) {
                         DeleteFile(file32out);
                         DeleteFile(file64out);
                         printf("Error: Update OUT timestamp 64\n");
                         return 1;
+                }

Subversion Repositories filter_foundry

filter_foundry/trunk/3264_mixer/foundry_3264_mixer.cpp @ 529 – Rev 455 → 456