Changeset 2955 for trunk/kLdr/kLdrModMachO.c

Timestamp:

Feb 7, 2007, 8:07:16 AM (19 years ago)

Author:

bird

Message:

Completed kldrModMachOParseLoadCommands and kldrModMachOSize. Added an kLdrErrStr API.

File:

• trunk/kLdr/kLdrModMachO.c (modified) (12 diffs)

trunk/kLdr/kLdrModMachO.c

@@ -99 +99 @@
     /** The link address. */
     KLDRADDR                LinkAddress;
+    /** The size of the mapped image. */
+    KLDRADDR                cbImage;
+    /** When set the load commands will be used when mapping / loading the bits.
+     * This is the case when segments are made up of sections that doesn't have
+     * proper ordering and/or aligning in the file alignment. */
+    int                     fMapUsingLoadCommands;
 
     /** Pointer to the load commands. (endian converted) */
@@ -353 +359 @@
         pModMachO->Hdr.reserved = 0;
     pModMachO->LinkAddress = 0;
+    pModMachO->cbImage = 0;
+    pModMachO->fMapUsingLoadCommands = 0;
     pModMachO->offSymbols = 0;
     pModMachO->cSymbols = 0;
@@ -408 +416 @@
     uint32_t cbLeft = pHdr->sizeofcmds;
     uint8_t *pb = pbLoadCommands;
+    int      cSegmentCommands = 0;
     int      fConvertEndian = pHdr->magic == IMAGE_MACHO32_SIGNATURE_OE
                            || pHdr->magic == IMAGE_MACHO64_SIGNATURE_OE;
@@ -447 +456 @@
                 if (u.pLoadCmd->cmdsize < sizeof(segment_command_32_t))
                     return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
+                if (    pHdr->magic != IMAGE_MACHO32_SIGNATURE_OE
+                    &&  pHdr->magic != IMAGE_MACHO32_SIGNATURE)
+                    return KLDR_ERR_MACHO_BIT_MIX;
                 if (fConvertEndian)
                 {
@@ -473 +485 @@
                 if (u.pSeg32->nsects * sizeof(section_32_t) > u.pLoadCmd->cmdsize - sizeof(segment_command_32_t))
                     return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
+                if (    pHdr->filetype == MH_OBJECT
+                    &&  cSegmentCommands > 0)
+                    return KLDR_ERR_MACHO_BAD_OBJECT_FILE;
+                cSegmentCommands++;
 
                 /* 
@@ -566 +582 @@
 
                             /* a new segment? */
-                            if (    pSect == pFirstSect
+                            if (    !cSegments
                                 ||  kLdrHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
                             {
@@ -580 +596 @@
                                 /* ok. count it and the string. */
                                 cSegments++;
-                                cbStringPool += kLdrHlpStrLen(pSect->segname) + 1;
+                                cbStringPool += kLdrHlpStrNLen(&pSect->segname[0], sizeof(pSect->segname)) + 1;
                             }
                             break;
@@ -595 +611 @@
             }
 
-            case LC_SEGMENT_64:
-                /* copy 32-bit code */
+            /*case LC_SEGMENT_64:
+                 copy 32-bit code 
                 break;
+            */
 
             case LC_SYMTAB:
@@ -656 +673 @@
                 break;
 
+            case LC_SEGMENT_64:
             case LC_LOADFVMLIB:
             case LC_IDFVMLIB:
@@ -684 +702 @@
     }
 
-    /* be strict (for now). */
+    /* be strict. */
     if (cbLeft)
         return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
 
+    switch (pHdr->filetype)
+    {
+        case MH_OBJECT:
+            if (!cSegments)
+                return KLDR_ERR_MACHO_BAD_OBJECT_FILE;
+            break;
+    }
+
     *pcSegments = cSegments;
-    *pcbStringPool = cLeft;
+    *pcbStringPool = cbStringPool;
 
     return 0;
@@ -708 +734 @@
 static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, uint32_t cbStringPool)
 {
+    union
+    {
+        const uint8_t              *pb;
+        const load_command_t       *pLoadCmd;
+        const segment_command_32_t *pSeg32;
+        const segment_command_64_t *pSeg64;
+        const symtab_command_t     *pSymTab;
+    } u;
+    uint32_t cLeft = pModMachO->Hdr.ncmds;
+    uint32_t cbLeft = pModMachO->Hdr.sizeofcmds;
+    const uint8_t *pb = pModMachO->pbLoadCommands;
+    int fFirstSegment = 1;
+    PKLDRSEG pSeg = &pModMachO->pMod->aSegments[0];
+    const uint32_t cSegments = pModMachO->pMod->cSegments;
+    uint32_t i;
+
+    while (cLeft-- > 0)
+    {
+        u.pb = pb;
+        cbLeft -= u.pLoadCmd->cmdsize;
+        pb += u.pLoadCmd->cmdsize;
+
+        /*
+         * Convert endian if needed, parse and validate the command.
+         */
+        switch (u.pLoadCmd->cmd)
+        {
+            case LC_SEGMENT_32:
+            {
+                section_32_t *pSect;
+                section_32_t *pFirstSect;
+                uint32_t cSectionsLeft;
+
+                pModMachO->LinkAddress = u.pSeg32->vmaddr;
+
+                /* 
+                 * convert, validate and parse the sections. 
+                 */
+                cSectionsLeft = u.pSeg32->nsects;
+                pFirstSect = pSect = (section_32_t *)(u.pSeg32 + 1);
+                while (cSectionsLeft-- > 0)
+                {
+                    switch (pModMachO->Hdr.filetype)
+                    {
+                        case MH_OBJECT:
+                        {
+                            /* Don't load debug symbols. (test this) */
+                            if (pSect->flags & S_ATTR_DEBUG)
+                                break;
+
+                            if (    fFirstSegment
+                                ||  kLdrHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
+                            {
+                                /* new segment. */
+                                pSeg->pvUser = NULL;
+                                pSeg->pchName = pbStringPool;
+                                pSeg->cchName = (uint32_t)kLdrHlpStrNLen(&pSect->segname[0], sizeof(pSect->sectname));
+                                kLdrHlpMemCopy(pbStringPool, &pSect->segname[0], pSeg->cchName);
+                                pbStringPool += pSeg->cchName;
+                                *pbStringPool++ = '\0';
+                                pSeg->SelFlat = 0;
+                                pSeg->Sel16bit = 0;
+                                pSeg->fFlags = 0;
+                                pSeg->enmProt = KLDRPROT_EXECUTE_WRITECOPY; /** @todo fixme! */
+                                pSeg->cb = pSect->size;
+                                pSeg->Alignment = (1 << pSect->align);
+                                pSeg->LinkAddress = pSect->addr;
+                                pSeg->offFile = pSect->offset ? pSect->offset : -1;
+                                pSeg->cbFile  = pSect->offset ? pSect->size : -1;
+                                pSeg->RVA = pSect->addr - pModMachO->LinkAddress;
+                                pSeg->cbMapped = 0;
+                                pSeg->MapAddress = 0;
+
+                                pSeg++;
+                                fFirstSegment = 0;
+                            }
+                            else if (!fFirstSegment)
+                            {
+                                /* update exiting segment */
+                                if (pSeg[-1].Alignment < (1 << pSect->align))
+                                    pSeg[-1].Alignment = (1 << pSect->align);
+                                if (pSect->addr < pSeg[-1].LinkAddress)
+                                    return KLDR_ERR_MACHO_BAD_SECTION; /** @todo move up! */
+
+                                if (    pSect->offset 
+                                    &&  pSeg[-1].cbFile == pSeg[-1].cb)
+                                {
+                                    if (    pSeg[-1].offFile + pSeg[-1].cbFile == pSect->offset
+                                        &&  pSeg[-1].cbFile == pSect->addr - pSeg[-1].LinkAddress)
+                                        pSeg[-1].cbFile = (off_t)(pSect->addr - pSeg[-1].LinkAddress) + pSect->size;
+                                    else
+                                    {
+                                        pSeg[-1].cbFile = pSeg[-1].offFile = -1;
+                                        pModMachO->fMapUsingLoadCommands = 1;
+                                    }
+                                }
+                                pSeg[-1].cb = pSect->addr - pSeg[-1].LinkAddress + pSect->size;
+
+                                /** @todo update the protection... */
+                            }
+                            break;
+                        }
+
+                        default:
+                            return KLDR_ERR_INVALID_PARAMETER;
+                    }
+
+                    /* next */
+                    pSect++;
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /* 
+     * Adjust mapping addresses calculating the image size.
+     */
+    pSeg = &pModMachO->pMod->aSegments[0];
+    switch (pModMachO->Hdr.filetype)
+    {
+        case MH_OBJECT:
+        {
+            KLDRADDR cb1;
+            size_t cb2;
+
+            for (i = 0; i < cSegments - 1; i++)
+            {
+                cb1 = pSeg[i + 1].LinkAddress - pSeg[i].LinkAddress;
+                cb2 = (size_t)cb1;
+                pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(size_t)0;
+            }
+            cb1 = KLDR_ALIGN_ADDR(pSeg[i].cb, pSeg[i].Alignment);
+            cb2 = (size_t)cb1;
+            pSeg[i].cbMapped = cb2 == cb1 ? cb2 : ~(size_t)0;
+
+            pModMachO->cbImage = pSeg[i].RVA + cb1;
+            break;
+        }
+    }
+
     return 0;
 }
@@ -1978 +2148 @@
 static KLDRADDR kldrModMachOSize(PKLDRMOD pMod)
 {
-#if 0
     PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
-    return pModMachO->Hdrs.OptionalHeader.SizeOfImage;
-#else
-    return 0;
-#endif
+    return pModMachO->cbImage;
 }