checksymbols.c

WinCE5.0部分核心源码

        if (g_Records[i].dwLength == sizeof(ROMHDR)) {
            
            //
            // If this _IS_ the TOC record, compute the ROM Offset.
            //
            dwROMOffsetRead = (DWORD) g_Records[i].dwStartAddress - (DWORD) g_pTOC;

//            printf("Checking record #%d for potential TOC (ROMOFFSET = 0x%08X)\n", i, dwROMOffsetRead);
            //
            // Read out the record to verify. (unadjusted)
            //
            fRet = ReadBinFile(pBuffer, g_Records[i].dwStartAddress, sizeof(ROMHDR), 0);
    
            if (fRet) {
                ROMHDR* pTOC = (ROMHDR*) pBuffer;
            
                if ((pTOC->physfirst == (g_dwImageStart - dwROMOffsetRead)) &&
                    (pTOC->physlast  == (g_dwImageStart - dwROMOffsetRead) + g_dwImageLength)) {

                    //
                    // Extra sanity check...
                    //
                    if (pTOC->dllfirst <= pTOC->dlllast && pTOC->dlllast == 0x02000000) { 
                        fFoundIt = TRUE;
                        break;
                    } else {
                        printf ("NOTICE! Record %d looked like a TOC except DLL first = 0x%08X, and DLL last = 0x%08X\r\n", i, pTOC->dllfirst, pTOC->dlllast);
                    }
                } else {
                    printf ("NOTICE! Record %d looked like a TOC except Phys first = 0x%08X, and Phys last = 0x%08X\r\n", i, pTOC->physfirst, pTOC->physlast);
                }
            }
        }
    }

    if (fFoundIt) {
        g_dwROMOffset = dwROMOffsetRead;
    } else {
        g_dwROMOffset = 0;
    }
//    printf("ROMOFFSET = 0x%08X\n", g_dwROMOffset);

    return 0;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void 
PrintTOC()
{
    BOOL  fRet;
    SYSTEMTIME st;

    if (!g_pTOC)
      return;

    //-------------------------------------------
    // Print header
    //
    fRet = ReadBinFile(pBuffer, g_pTOC, sizeof(ROMHDR), g_dwROMOffset);

    if (fRet) {
        ROMHDR* pTOC = (ROMHDR*) pBuffer;

        g_dwNumModules = pTOC->nummods;
        g_dwNumFiles = pTOC->numfiles;
        g_dwNumCopySects = pTOC->ulCopyEntries;
        g_dwCopyOffset = pTOC->ulCopyOffset;

    } else {
        printf("Couldn't locate TOC data\n");
        return;
    }


    //-------------------------------------------
    // Print Modules
    //
    fRet = ReadBinFile(pBuffer, (DWORD) g_pTOC + sizeof(ROMHDR), sizeof(TOCentry) * g_dwNumModules, g_dwROMOffset);

    if (fRet) {
        TOCentry* pte = (TOCentry*) pBuffer;
        e32_rom e32, *pe32 = &e32;
        o32_rom o32, *po32 = &o32;
        DWORD i;
        char szFilename[MAX_PATH];
        char szStatus[128];
        FILETIME ft;

        printf("\n");

        for (i=0;i < g_dwNumModules; i++) {

            HANDLE hFile;

            sprintf(szStatus, "okay");
            fRet = ReadBinFile((PBYTE) szFilename, (DWORD) pte[i].lpszFileName, 0, g_dwROMOffset);
            FileTimeToSystemTime(&(pte[i].ftTime), &st);

            hFile = CreateFile(szFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

            if (hFile == INVALID_HANDLE_VALUE) {
                sprintf(szStatus, "FILE NOT FOUND!");
                g_fRet = TRUE;
            } else {
                if (GetFileTime(hFile, NULL, NULL, &ft)) {
                    if (CompareFileTime(&(pte[i].ftTime), &ft)) {
                        sprintf(szStatus, "Timestamps do not match!");
                        g_fRet = TRUE;
                    } else {
                        if (GetFileSize(hFile, NULL) != pte[i].nFileSize) {
                            sprintf(szStatus, "File sizes do not match!");
                            g_fRet = TRUE;
                        }
                    }
                } else {
                    sprintf(szStatus, "Couldn't get file time!");
                    g_fRet = TRUE;
                }
                CloseHandle(hFile);
            }
            printf("    %2d/%02d/%04d  %02d:%02d:%02d  %10d  %20s (%s)\n", 
                   st.wMonth, st.wDay, st.wYear,
                   st.wHour, st.wMinute, st.wSecond,
                   pte[i].nFileSize, szFilename, szStatus);
        }
    } else {
        printf("ERROR: Couldn't locate Modules data\n");
    }

}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
    DWORD dwRecAddr, dwRecLen, dwRecChk;
    DWORD dwRead;
    BOOL  fRet;
    LPTSTR pszCmdLine;
    char szAscii[17];

    pszCmdLine = GetCommandLine();

    // Parse command line parameters (updates the ui variables).
    if (!parseCmdLine(pszCmdLine))  
       return 0;
   
    
    printf("CHECKSYMBOLS... %s\n", g_szFilename);
    
    
    hFile = CreateFile(g_szFilename, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 
                       NULL, OPEN_EXISTING, 0, 0);

    if (hFile == INVALID_HANDLE_VALUE) {
        printf ("Error opening %s\n", g_szFilename);
        return 0;
    }
    

    fRet = ReadFile(hFile, pBuffer, 7, &dwRead, NULL);
    
    if (!fRet || dwRead != 7) {
        printf("Error reading %s (%d)\n", g_szFilename, __LINE__);
        CloseHandle(hFile);
        return 0;
    }
    
    if (memcmp( pBuffer, "B000FF\x0A", 7 )) {
        printf("Missing initial signature (BOOOFF\x0A). Not a BIN file\n");
        CloseHandle(hFile);
        return 0;
    }

    //
    // Read the image header
    // 
    fRet = ReadFile(hFile, &g_dwImageStart, sizeof(DWORD), &dwRead, NULL);

    if (!fRet || dwRead != sizeof(DWORD)) {
        CloseHandle(hFile);
        return 0;
    }

    fRet = ReadFile(hFile, &g_dwImageLength, sizeof(DWORD), &dwRead, NULL);

    if (!fRet || dwRead != sizeof(DWORD)) {
        CloseHandle(hFile);
        return 0;
    }

//    printf("Image Start = 0x%08X, length = 0x%08X\n", g_dwImageStart, g_dwImageLength);

    szAscii[16] = '\0';
    //
    // Now read the records.
    //
    while (1) {
                
        //
        // Record address
        //
        fRet = ReadFile(hFile, &dwRecAddr, sizeof(DWORD), &dwRead, NULL);

        if (!fRet || dwRead != sizeof(DWORD)) {
            break;
        }

        //
        // Record length
        //
        fRet = ReadFile(hFile, &dwRecLen, sizeof(DWORD), &dwRead, NULL);

        if (!fRet || dwRead != sizeof(DWORD)) {
            break;
        }

        //
        // Record checksum
        //
        fRet = ReadFile(hFile, &dwRecChk, sizeof(DWORD), &dwRead, NULL);

        if (!fRet || dwRead != sizeof(DWORD)) {
            break;
        }

        g_Records[g_dwNumRecords].dwStartAddress = dwRecAddr;
        g_Records[g_dwNumRecords].dwLength       = dwRecLen;
        g_Records[g_dwNumRecords].dwChecksum     = dwRecChk;
        g_Records[g_dwNumRecords].dwFilePointer  = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);

        if (g_fPrintRecords || g_fPrintData) {
            printf("Record [%3d] : Start = 0x%08X, Length = 0x%08X, Chksum = 0x%08X\n", g_dwNumRecords, dwRecAddr, dwRecLen, dwRecChk);
        }
        g_dwNumRecords++;
        
        if (dwRecAddr == 0) {
            g_dwStartAddr = dwRecLen;
            break;
        }
        
        SetFilePointer(hFile, dwRecLen, NULL, FILE_CURRENT);

    }

    //
    // Find pTOC
    //
    fRet = ReadBinFile(pBuffer, g_dwImageStart + 0x40, 8, 0);
    if (fRet) {
        g_pTOC = *((PDWORD) (pBuffer + 4));
    } else {
        printf ("Couldn't find pTOC @ Image Start (0x%08X) + 0x40\n", g_dwImageStart);
        return TRUE;
    }

    ComputeRomOffset();

    if (g_fPrintTOC || g_fPrintOBJ) {
        PrintTOC();
    }

    CloseHandle(hFile);
    return g_fRet;
}