[PE2MACHO] Refactor pe2macho

Author: DistroHopper39B

sdk/tools/pe2macho/macho.h

@@ -18,7 +18,8 @@
 #define i386_THREAD_STATE 1
 
 /* Mach-O header */
-typedef struct {
+typedef struct
+{
     UINT32 MagicNumber; /* Mach-O magic number. */
 
     INT32 CpuType; /* CPU type */
@@ -32,7 +33,8 @@ typedef struct {
     UINT32 Flags; /* Executable flags */
 } MACHO_HEADER, *PMACHO_HEADER;
 
-typedef struct {
+typedef struct
+{
     UINT32 Command; /* LC_SEGMENT */
     UINT32 CommandSize; /* Size of segment command */
 
@@ -52,7 +54,8 @@ typedef struct {
     UINT32 Flags; /* Segment flags */
 } MACHO_SEGMENT_COMMAND, *PMACHO_SEGMENT_COMMAND;
 
-typedef struct {
+typedef struct
+{
     UINT32 Eax;
     UINT32 Ebx;
     UINT32 Ecx;
@@ -69,20 +72,22 @@ typedef struct {
     UINT32 Es;
     UINT32 Fs;
     UINT32 Gs;
-} MACHO_THREAD_STATE_32;
+} MACHO_THREAD_STATE_I386;
 
-typedef struct {
+typedef struct
+{
     UINT32 Command; /* LC_UNIXTHREAD */
     UINT32 CommandSize; /* Size of segment command */
     UINT32 Flavor; /* Architecture of thread state */
     UINT32 Count; /* Size of saved state */
-    
-    MACHO_THREAD_STATE_32 State; /* State */
-} MACHO_THREAD_COMMAND_X86, *PMACHO_THREAD_COMMAND_X86;
+
+    MACHO_THREAD_STATE_I386 State; /* State */
+} MACHO_THREAD_COMMAND_I386, *PMACHO_THREAD_COMMAND_I386;
 
 #define i386_THREAD_STATE_COUNT	16
 
-typedef struct {
+typedef struct
+{
     char SectionName[16]; /* Name of this section */
     char SegmentName[16]; /* Segment this section goes in */
 

sdk/tools/pe2macho/pe2macho.c

@@ -9,6 +9,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <errno.h>
 
 // host_includes
 #include <typedefs.h>
@@ -33,14 +34,14 @@ FindFileHeaderFromDosHeader(PIMAGE_DOS_HEADER PeBase)
 {
     PIMAGE_FILE_HEADER  FileHeader;
     PUINT               Signature;
-    
+
     Signature = (PUINT) (((PUCHAR) PeBase) + PeBase->e_lfanew);
-    
+
     if (*Signature != IMAGE_NT_SIGNATURE)
     {
         return NULL;
     }
-    
+
     FileHeader = (PIMAGE_FILE_HEADER) (Signature + 1);
     return FileHeader;
 }
@@ -50,84 +51,93 @@ PIMAGE_OPTIONAL_HEADER32
 FindOptionalHeaderFromFileHeader(PIMAGE_FILE_HEADER FileHeader)
 {
     PIMAGE_OPTIONAL_HEADER32    OptionalHeader;
-    
-    OptionalHeader = (PIMAGE_OPTIONAL_HEADER32) (((PUCHAR) FileHeader) + sizeof(IMAGE_FILE_HEADER));
+
+    OptionalHeader = (PIMAGE_OPTIONAL_HEADER32) (((PUCHAR) FileHeader)
+                                                 + sizeof(IMAGE_FILE_HEADER));
     if (OptionalHeader->Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
     {
         return NULL;
     }
+
     return OptionalHeader;
 }
 
 static
 PMACHO_HEADER
 CreateMachOHeaderFromPeHeader(PIMAGE_OPTIONAL_HEADER32 OptionalHeader,
-                                UINT32 PeSize,
-                                PUINT MachoHeaderSize)
+                              UINT32 PeSize,
+                              PUINT MachoHeaderSize)
 {
     PMACHO_HEADER               MachoHeader;
     PMACHO_SEGMENT_COMMAND      MachoSegmentCommand;
-    PMACHO_THREAD_COMMAND_X86   MachoUnixThread;
-    
+    PMACHO_THREAD_COMMAND_I386  MachoUnixThread;
+
     *MachoHeaderSize = sizeof(MACHO_HEADER)
-                    + sizeof(MACHO_SEGMENT_COMMAND)
-                    + sizeof(MACHO_THREAD_COMMAND_X86);
-                    
+                     + sizeof(MACHO_SEGMENT_COMMAND)
+                     + sizeof(MACHO_THREAD_COMMAND_I386);
+
     MachoHeader = calloc(1, *MachoHeaderSize);
     if (!MachoHeader)
     {
-        fprintf(stderr, "Could not allocate %d bytes for Mach-O info\n", *MachoHeaderSize);
+        fprintf(stderr, "Could not allocate %d bytes for Mach-O info\n",
+                *MachoHeaderSize);
         return NULL;
     }
-            
+
     // Fill out Mach-O header.
     MachoHeader->MagicNumber    = MACHO_MAGIC;
-    
+
     MachoHeader->CpuType        = 7; // x86
     MachoHeader->CpuSubtype     = 3; // all x86
-    
+
     MachoHeader->FileType       = 2; // kernel (static linked)
-    
+
     MachoHeader->NumberOfCmds   = 2;
     MachoHeader->SizeOfCmds     = *MachoHeaderSize - sizeof(MACHO_HEADER);
-    
+
     MachoHeader->Flags          = 1;
-    
+
     // Fill out first load command.
-    MachoSegmentCommand = (PMACHO_SEGMENT_COMMAND) (((PUCHAR) MachoHeader) + sizeof(MACHO_HEADER));
-    
+    MachoSegmentCommand = (PMACHO_SEGMENT_COMMAND) (((PUCHAR) MachoHeader)
+                                                    + sizeof(MACHO_HEADER));
+
     MachoSegmentCommand->Command            = MACHO_LC_SEGMENT;
     MachoSegmentCommand->CommandSize        = sizeof(MACHO_SEGMENT_COMMAND);
-    
+
     strcpy(MachoSegmentCommand->SegmentName, "__PE_FILE__");
-    
+
     MachoSegmentCommand->VMAddress          = OptionalHeader->ImageBase;
-    
-    /* 
-     * SizeOfImage should always be a multiple of SectionAlignment, but it isn't on GCC and boot.efi wants it to
-     * also be aligned to the EFI page size (0x1000), plus one so that BootArgs is allocated correctly.
+
+    /*
+     * SizeOfImage should always be a multiple of SectionAlignment, but it isn't on GCC and
+     * boot.efi wants it to also be aligned to the EFI page size (0x1000), plus one so that
+     * BootArgs is allocated correctly.
      */
-    MachoSegmentCommand->VMSize             = ROUND_UP(OptionalHeader->SizeOfImage, EFI_PAGE_SIZE) + 1;
-    
+
+    MachoSegmentCommand->VMSize             = ROUND_UP(OptionalHeader->SizeOfImage,
+                                                       EFI_PAGE_SIZE) + 1;
+
     MachoSegmentCommand->FileOffset         = HEADER_ADDITIONAL_BYTES;
     MachoSegmentCommand->FileSize           = PeSize;
-    
+
     MachoSegmentCommand->MaximumProtection  = 7; // ???
     MachoSegmentCommand->InitialProtection  = 5; // ???
-    
+
     MachoSegmentCommand->NumberOfSections   = 0;
     MachoSegmentCommand->Flags              = 0;
-    
-    MachoUnixThread = (PMACHO_THREAD_COMMAND_X86) (((PUCHAR) MachoSegmentCommand) + sizeof(MACHO_SEGMENT_COMMAND));
-    
-    MachoUnixThread->Command            = MACHO_LC_UNIXTHREAD;
-    MachoUnixThread->CommandSize        = sizeof(MACHO_THREAD_COMMAND_X86);
-    MachoUnixThread->Flavor             = i386_THREAD_STATE;
-    MachoUnixThread->Count              = i386_THREAD_STATE_COUNT;
-    
+
+    MachoUnixThread = (PMACHO_THREAD_COMMAND_I386) (((PUCHAR) MachoSegmentCommand)
+                                                   + sizeof(MACHO_SEGMENT_COMMAND));
+
+    MachoUnixThread->Command                = MACHO_LC_UNIXTHREAD;
+    MachoUnixThread->CommandSize            = sizeof(MACHO_THREAD_COMMAND_I386);
+    MachoUnixThread->Flavor                 = i386_THREAD_STATE;
+    MachoUnixThread->Count                  = i386_THREAD_STATE_COUNT;
+
     // all registers are blank except for EIP, which is the entry point!
-    MachoUnixThread->State.Eip          = OptionalHeader->ImageBase + OptionalHeader->AddressOfEntryPoint;
-        
+    MachoUnixThread->State.Eip              = OptionalHeader->ImageBase +
+                                              OptionalHeader->AddressOfEntryPoint;
+
     return MachoHeader;
 }
 
@@ -138,83 +148,85 @@ main(INT argc, PCHAR argv[])
     UINT32  InputFileLength, OutputFileLength;
     PUCHAR  InputFileBuffer, OutputFileBuffer;
     UINT32  ObjectsWritten;
-    
+
     PIMAGE_FILE_HEADER          PeFileHeader;
     PIMAGE_OPTIONAL_HEADER32    PeOptionalHeader;
-    
+
     PMACHO_HEADER               MachoHeader;
     UINT32                      MachoHeaderSize;
-    
-    
+
+
     // Check arguments
     if (argc != 3)
     {
         fprintf(stderr, "Usage: pe2macho [input file] [output file]\n");
         return 1;
     }
-    
+
     // Open file
     InputFile = fopen(argv[1], "rb");
     if (!InputFile)
     {
-        fprintf(stderr, "Cannot find input file!\n");
+        fprintf(stderr, "Cannot find input file '%s': %s\n",
+                argv[1], strerror(errno));
         return 2;
     }
-    
+
     // Find end of file
     fseek(InputFile, 0, SEEK_END);
     InputFileLength = ftell(InputFile);
     fseek(InputFile, 0, SEEK_SET);
-    
+
     InputFileBuffer = malloc(InputFileLength + 1);
     if (!InputFileBuffer)
     {
         fprintf(stderr, "Could not allocate %d bytes for input file\n", InputFileLength + 1);
         fclose(InputFile);
         return 3;
     }
-    
+
     // Read contents of file into buffer and then close file
     fread(InputFileBuffer, InputFileLength, 1, InputFile);
     fclose(InputFile);
-    
+
     // Find DOS header
     if (((PIMAGE_DOS_HEADER) InputFileBuffer)->e_magic != IMAGE_DOS_MAGIC)
     {
-        fprintf(stderr, "Input file not a valid MZ image. (expected 0x%X, got 0x%X)\n", IMAGE_DOS_MAGIC, ((PIMAGE_DOS_HEADER)InputFileBuffer)->e_magic);
+        fprintf(stderr, "Input file not a valid MZ image. (expected 0x%X, got 0x%X)\n",
+                IMAGE_DOS_MAGIC, ((PIMAGE_DOS_HEADER)InputFileBuffer)->e_magic);
         return 4;
     }
-    
+
     // Find PE/COFF file header
     PeFileHeader = FindFileHeaderFromDosHeader((PIMAGE_DOS_HEADER) InputFileBuffer);
     if (!PeFileHeader)
     {
         fprintf(stderr, "Input file not a valid PE/COFF image!\n");
         return 5;
     }
-    
+
     // Check arch
     if (PeFileHeader->Machine != IMAGE_FILE_MACHINE_I386)
     {
-        fprintf(stderr, "Only 32 bit x86 executables are supported at this time.\n");
+        fprintf(stderr, "Only i386 executables are supported at this time.\n");
         return 6;
     }
-    
+
     // Make sure there's an optional header
     if (!PeFileHeader->SizeOfOptionalHeader)
     {
         fprintf(stderr, "No optional header found!\n");
         return 7;
     }
-    
+
     // Find optional header
     PeOptionalHeader = FindOptionalHeaderFromFileHeader(PeFileHeader);
     if (!PeOptionalHeader)
     {
         fprintf(stderr, "Invalid optional header!\n");
         return 8;
     }
-    
+
     // Convert PE executable header to Mach-O
     MachoHeader = CreateMachOHeaderFromPeHeader(PeOptionalHeader,
                                                 InputFileLength,
@@ -224,40 +236,48 @@ main(INT argc, PCHAR argv[])
         fprintf(stderr, "Failed to create Mach-O header!\n");
         return 9;
     }
-    
+
     // Allocate new buffer for output file
     OutputFileLength = InputFileLength + HEADER_ADDITIONAL_BYTES;
     OutputFileBuffer = calloc(1, OutputFileLength);
     if (!OutputFileBuffer)
     {
-        fprintf(stderr, "Failed to allocate %d bytes for output file\n", OutputFileLength);
+        fprintf(stderr, "Failed to allocate %d bytes for output file\n",
+                OutputFileLength);
         return 10;
     }
-    
+
     // Copy Mach-O header to top of buffer
-    memcpy(OutputFileBuffer, MachoHeader, MachoHeaderSize);
-    
+    memcpy(OutputFileBuffer,
+           MachoHeader,
+           MachoHeaderSize);
+
     // Copy output file 4096 bytes in
     // It will be loaded at its original load addr
-    memcpy(OutputFileBuffer + HEADER_ADDITIONAL_BYTES, InputFileBuffer, InputFileLength);
-    
+    memcpy(OutputFileBuffer + HEADER_ADDITIONAL_BYTES,
+           InputFileBuffer,
+           InputFileLength);
+
     // Open output file
     OutputFile = fopen(argv[2], "wb");
     if (!OutputFile)
     {
-        fprintf(stderr, "Cannot open output file: %s\n", argv[2]);
+        fprintf(stderr, "Cannot open output file %s: %s\n",
+                argv[2], strerror(errno));
         return 11;
     }
-    
+
     ObjectsWritten = fwrite(OutputFileBuffer, OutputFileLength, 1, OutputFile);
     if (!ObjectsWritten)
     {
-        fprintf(stderr, "Cannot write to output file: %s\n", argv[2]);
+        fprintf(stderr, "Cannot write to output file %s: %s\n",
+                argv[2], strerror(errno));
         fclose(OutputFile);
         return 12;
     }
-    
+
     fclose(OutputFile);
-    printf("Successfully converted PE image %s to Mach-O image %s\n", argv[1], argv[2]);    
+    printf("Successfully converted PE image %s to Mach-O image %s\n",
+           argv[1], argv[2]);
     return 0;
 }