gecko-dev/tools/dumpdeps/dumpdeps.cpp

552 строки
15 KiB
C++
Исходник Обычный вид История

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* The contents of this file are subject to the Mozilla Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is the Mozilla browser.
*
* The Initial Developer of the Original Code is Netscape
* Communications, Inc. Portions created by Netscape are
* Copyright (C) 1999, Mozilla. All Rights Reserved.
*
* Contributor(s):
* Adam Lock <adamlock@netscape.com>
*/
// BEGIN WINDOWS SPECIFIC
#include <windows.h>
// END WINDOWS SPECIFIC
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <vector>
#include <string>
#include "nsISupportsPrimitives.h"
#include "nsXPIDLString.h"
#include "nsID.h"
#include "nsCOMPtr.h"
#include "nsIRegistry.h"
#include "nsILocalFile.h"
extern "C" NS_EXPORT nsresult NS_RegistryGetFactory(nsIFactory** aFactory);
inline wchar_t * A2W(const char *lpa, wchar_t *lpw,int nChars)
{
lpw[0] = '\0';
// BEGIN WINDOWS SPECIFIC
MultiByteToWideChar(CP_ACP, 0, lpa, -1, lpw, nChars);
// END WINDOWS SPECIFIC
return lpw;
}
struct factory
{
nsID mCID;
std::string mLibrary;
factory(nsID cid, const char * library) :
mCID(cid),
mLibrary(library)
{
}
};
struct progid2cid
{
std::string mProgID;
nsID mCID;
progid2cid(const char *progID, nsID cid) :
mProgID(progID),
mCID(cid)
{
}
};
struct library
{
std::string mFullPath;
std::string mFile;
library(const char *fullPath, const char *file) :
mFullPath(fullPath),
mFile(file)
{
}
};
// These should really be std::map types to aid searching but aren't
std::vector<factory> listCLSIDs;
std::vector<progid2cid> listProgIDs;
std::vector<library> listComponents;
// Function declarations
PRBool ReadFileToBuffer(const char *szFile, char **ppszBuffer, long *pnBufferSize);
int ScanBuffer(const char *pszBuffer, long nBufferSize, const void *szPattern, long nPatternSize);
nsresult ReadComponentRegistry();
void OutputCID(const nsID &cid);
void OutputProgId(const char *szProgID);
void OutputLibrary(const char *szLibrary);
PRBool LibraryImplementsCID(const char *szLibrary, const nsID &cid);
int main(int argc, char *argv[])
{
// These should be set by command switches but aren't at the moment
PRBool bSearchForUnicodeProgIDs = PR_FALSE;
PRBool bSearchForUnicodeLibraries = PR_FALSE;
if (argc != 2)
{
fprintf(stderr, "Usage: dumpdeps <mozbindirectory>\n");
return 1;
}
std::string sBinDirPath = argv[1];
nsIServiceManager *mServiceManager;
nsILocalFile *pBinDirPath = nsnull;
nsresult res = NS_NewLocalFile(sBinDirPath.c_str(), &pBinDirPath);
// Initialise XPCOM
if (pBinDirPath == nsnull)
{
fprintf(stderr, "Error: Could not create object to represent mozbindirectory - is the path correct?\n");
return 1;
}
NS_InitXPCOM(&mServiceManager, pBinDirPath);
NS_RELEASE(pBinDirPath);
// Read the component registry to fill the arrays with CLSIDs
ReadComponentRegistry();
// Locate all libraries and add them to the components list
// BEGIN WINDOWS SPECIFIC
for (int n = 0; n < 2; n++)
{
// Windows specific paths
std::string sFolder;
if (n == 0)
{
sFolder = sBinDirPath + "\\";
}
else if (n == 1)
{
sFolder = sBinDirPath + "\\components\\";
}
std::string sPattern = sFolder + "*.dll";
WIN32_FIND_DATA findData;
HANDLE h = FindFirstFile(sPattern.c_str(), &findData);
if (h)
{
do {
std::string fullPath = sFolder + findData.cFileName;
listComponents.push_back(library(fullPath.c_str(), findData.cFileName));
} while (FindNextFile(h, &findData));
}
FindClose(h);
}
// END WINDOWS SPECIFIC
// Enumerate through all libraries looking for dependencies
std::vector<library>::const_iterator i;
for (i = listComponents.begin(); i != listComponents.end(); i++)
{
char *pszBuffer = NULL;
long nBufferSize = 0;
if (ReadFileToBuffer((*i).mFullPath.c_str(), &pszBuffer, &nBufferSize))
{
printf("Library \"%s\"\n", (*i).mFullPath.c_str());
// Print out implements
printf(" Implements:\n");
// Search for CIDs implemented by this library
std::vector<factory>::const_iterator j;
for (j = listCLSIDs.begin(); j != listCLSIDs.end(); j++)
{
if (LibraryImplementsCID((*i).mFile.c_str(), (*j).mCID))
{
OutputCID((*j).mCID);
}
}
// Print out references
printf(" References:\n");
// Search for CIDs not implemented by this library but referenced
for (j = listCLSIDs.begin(); j != listCLSIDs.end(); j++)
{
if (!LibraryImplementsCID((*i).mFile.c_str(), (*j).mCID) &&
ScanBuffer(pszBuffer, nBufferSize, &(*j).mCID, sizeof((*j).mCID)) == 1)
{
OutputCID((*j).mCID);
}
}
// Search for ProgIds
wchar_t szWTmp[1024];
std::vector<progid2cid>::const_iterator k;
for (k = listProgIDs.begin(); k != listProgIDs.end(); k++)
{
// Skip ProgIds that the library implements
if (LibraryImplementsCID((*i).mFile.c_str(), (*k).mCID))
{
continue;
}
// Search for ANSI strings
const char *szA = (*k).mProgID.c_str();
int nLength = (*k).mProgID.length();
if (ScanBuffer(pszBuffer, nBufferSize, szA, nLength) == 1)
{
OutputProgId(szA);
continue;
}
if (bSearchForUnicodeProgIDs)
{
// Search for Unicode strings
wchar_t *szW = A2W((*k).mProgID.c_str(), szWTmp, sizeof(szWTmp) / sizeof(szWTmp[0]));
if (ScanBuffer(pszBuffer, nBufferSize, szW, nLength * sizeof(wchar_t)) == 1)
{
printf("UNICODE Progid\n");
OutputProgId(szA);
continue;
}
}
}
printf(" Statically linked to:\n");
std::vector<library>::const_iterator l;
for (l = listComponents.begin(); l != listComponents.end(); l++)
{
// Skip when the full path and the component point to the same thing
if (i == l)
{
continue;
}
// Search for ANSI strings
const char *szA = (*l).mFile.c_str();
int nLength = (*l).mFile.length();
if (ScanBuffer(pszBuffer, nBufferSize, szA, nLength) == 1)
{
OutputLibrary(szA);
continue;
}
if (bSearchForUnicodeLibraries)
{
// Search for Unicode strings
wchar_t *szW = A2W((*l).mFile.c_str(), szWTmp, sizeof(szWTmp) / sizeof(szWTmp[0]));
if (ScanBuffer(pszBuffer, nBufferSize, szW, nLength * sizeof(wchar_t)) == 1)
{
printf("UNICODE library\n");
OutputLibrary(szA);
continue;
}
}
}
delete []pszBuffer;
}
}
return 0;
}
// Reads a file into a big buffer and returns it
PRBool ReadFileToBuffer(const char *szFile, char **ppszBuffer, long *pnBufferSize)
{
// Allocate a memory buffer to slurp up the whole file
struct _stat srcStat;
_stat(szFile, &srcStat);
char *pszBuffer = new char[srcStat.st_size / sizeof(char)];
if (pszBuffer == NULL)
{
printf("Error: Could not allocate buffer for file \"%s\"\n", szFile);
return PR_FALSE;
}
FILE *fSrc = fopen(szFile, "rb");
if (fSrc == NULL)
{
printf("Error: Could not open file \"%s\"\n", szFile);
delete []pszBuffer;
return PR_FALSE;
}
size_t sizeSrc = srcStat.st_size;
size_t sizeRead = 0;
// Dumb but effective
sizeRead = fread(pszBuffer, 1, sizeSrc, fSrc);
fclose(fSrc);
if (sizeRead != sizeSrc)
{
printf("Error: Could not read all of file \"%s\"\n", szFile);
delete []pszBuffer;
return PR_FALSE;
}
*ppszBuffer = pszBuffer;
*pnBufferSize = sizeRead;
return PR_TRUE;
}
// Searchs for the specified pattern in the buffer
int ScanBuffer(const char *pszBuffer, long nBufferSize, const void *szPattern, long nPatternSize)
{
// Scan through buffer, one byte at a time doing a memcmp against the
// provided binary data.
for (size_t i = 0; i < nBufferSize - nPatternSize; i++)
{
if (memcmp(&pszBuffer[i], szPattern, nPatternSize) == 0)
{
return 1;
}
}
return 0;
}
// Prints a CID with the ProgId and library if they are there too.
void OutputCID(const nsID &cid)
{
std::vector<progid2cid>::const_iterator i;
for (i = listProgIDs.begin(); i != listProgIDs.end(); i++)
{
if (memcmp(&cid, &(*i).mCID, sizeof(nsID)) == 0)
{
printf(" ProgId = \"%s\"\n", (*i).mProgID.c_str());
printf(" CLSID = %s\n", cid.ToString());
std::vector<factory>::const_iterator j;
for (j = listCLSIDs.begin(); j != listCLSIDs.end(); j++)
{
if (memcmp(&cid, &(*j).mCID, sizeof(nsID)) == 0)
{
printf(" Library = %s\n", (*j).mLibrary.c_str());
}
}
return;
}
}
printf(" CLSID = %s\n", cid.ToString());
}
// Outputs the ProgId with the CID and library if they are there too.
void OutputProgId(const char *szProgID)
{
std::vector<progid2cid>::const_iterator i;
for (i = listProgIDs.begin(); i != listProgIDs.end(); i++)
{
if (strcmp((*i).mProgID.c_str(), szProgID) == 0)
{
printf(" ProgId = \"%s\"\n", (*i).mProgID.c_str());
printf(" CLSID = %s\n", (*i).mCID.ToString());
std::vector<factory>::const_iterator j;
for (j = listCLSIDs.begin(); j != listCLSIDs.end(); j++)
{
if (memcmp(&(*i).mCID, &(*j).mCID, sizeof(nsID)) == 0)
{
printf(" Library = %s\n", (*j).mLibrary.c_str());
}
}
return;
}
}
printf(" ProgID \"%s\"\n", szProgID);
}
// Outputs a library name
void OutputLibrary(const char *szLibrary)
{
printf(" DLL \"%s\"\n", szLibrary);
}
// Tests whether a library implements the specified CID
PRBool LibraryImplementsCID(const char *szLibrary, const nsID &cid)
{
// Search for CID - vector should really be a map, but it isn't
std::vector<factory>::const_iterator i;
for (i = listCLSIDs.begin(); i != listCLSIDs.end(); i++)
{
if (memcmp(&cid, &(*i).mCID, sizeof(nsID)) == 0)
{
if (strstr((*i).mLibrary.c_str(), szLibrary) != NULL)
{
return PR_TRUE;
}
return PR_FALSE;
}
}
return PR_FALSE;
}
// The following horrific-ness is ripped from nsComponentManager.cpp and sewn
// back together which is why it may look nasty.
//
// Basically it opens the registry and finds the CIDs, libraries and ProgIDs
// therein and adds them to some lists for easy lookup.
nsresult ReadComponentRegistry()
{
nsIRegistry *mRegistry = nsnull;
nsresult rv = NS_OK;
// We need to create our registry. Since we are in the constructor
// we haven't gone as far as registering the registry factory.
// Hence, we hand create a registry.
if (mRegistry == nsnull) {
nsIFactory *registryFactory = nsnull;
rv = NS_RegistryGetFactory(&registryFactory);
if (NS_SUCCEEDED(rv))
{
rv = registryFactory->CreateInstance(NULL, NS_GET_IID(nsIRegistry),(void **)&mRegistry);
if (NS_FAILED(rv)) return rv;
NS_RELEASE(registryFactory);
}
}
// Open the App Components registry. We will keep it open forever!
rv = mRegistry->OpenWellKnownRegistry(nsIRegistry::ApplicationComponentRegistry);
if (NS_FAILED(rv)) return rv;
nsRegistryKey mXPCOMKey;
nsRegistryKey mClassesKey;
nsRegistryKey mCLSIDKey;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
const char xpcomKeyName[]="software/mozilla/XPCOM";
const char classesKeyName[]="progID";
const char classIDKeyName[]="classID";
const char componentsKeyName[]="components";
const char componentLoadersKeyName[]="componentLoaders";
const char xpcomComponentsKeyName[]="software/mozilla/XPCOM/components";
const char classIDValueName[]="ClassID";
const char classNameValueName[]="ClassName";
const char inprocServerValueName[]="InprocServer";
const char componentTypeValueName[]="ComponentType";
const char nativeComponentType[]="application/x-mozilla-native";
nsRegistryKey xpcomKey;
rv = mRegistry->AddSubtree(nsIRegistry::Common, xpcomKeyName, &xpcomKey);
if (NS_FAILED(rv)) return rv;
rv = mRegistry->AddSubtree(xpcomKey, componentsKeyName, &mXPCOMKey);
if (NS_FAILED(rv)) return rv;
rv = mRegistry->AddSubtree(xpcomKey, classesKeyName, &mClassesKey);
if (NS_FAILED(rv)) return rv;
rv = mRegistry->AddSubtree(xpcomKey, classIDKeyName, &mCLSIDKey);
if (NS_FAILED(rv)) return rv;
// Read in all CID entries and populate the mFactories
nsCOMPtr<nsIEnumerator> cidEnum;
rv = mRegistry->EnumerateSubtrees( mCLSIDKey, getter_AddRefs(cidEnum));
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIRegistryEnumerator> regEnum = do_QueryInterface(cidEnum, &rv);
if (NS_FAILED(rv)) return rv;
rv = regEnum->First();
for (rv = regEnum->First();
NS_SUCCEEDED(rv) && (regEnum->IsDone() != NS_OK);
rv = regEnum->Next())
{
const char *cidString;
nsRegistryKey cidKey;
/*
* CurrentItemInPlaceUTF8 will give us back a _shared_ pointer in
* cidString. This is bad XPCOM practice. It is evil, and requires
* great care with the relative lifetimes of cidString and regEnum.
*
* It is also faster, and less painful in the allocation department.
*/
rv = regEnum->CurrentItemInPlaceUTF8(&cidKey, &cidString);
if (NS_FAILED(rv)) continue;
// Create the CID entry
nsXPIDLCString library;
rv = mRegistry->GetStringUTF8(cidKey, inprocServerValueName,
getter_Copies(library));
if (NS_FAILED(rv)) continue;
nsCID aClass;
if (!(aClass.Parse(cidString))) continue;
nsXPIDLCString componentType;
if (NS_FAILED(mRegistry->GetStringUTF8(cidKey, componentTypeValueName,
getter_Copies(componentType))))
continue;
listCLSIDs.push_back(factory(aClass, library));
}
// Finally read in PROGID -> CID mappings
nsCOMPtr<nsIEnumerator> progidEnum;
rv = mRegistry->EnumerateSubtrees( mClassesKey, getter_AddRefs(progidEnum));
if (NS_FAILED(rv)) return rv;
regEnum = do_QueryInterface(progidEnum, &rv);
if (NS_FAILED(rv)) return rv;
rv = regEnum->First();
for (rv = regEnum->First();
NS_SUCCEEDED(rv) && (regEnum->IsDone() != NS_OK);
rv = regEnum->Next())
{
const char *progidString;
nsRegistryKey progidKey;
/*
* CurrentItemInPlaceUTF8 will give us back a _shared_ pointer in
* progidString. This is bad XPCOM practice. It is evil, and requires
* great care with the relative lifetimes of progidString and regEnum.
*
* It is also faster, and less painful in the allocation department.
*/
rv = regEnum->CurrentItemInPlaceUTF8(&progidKey, &progidString);
if (NS_FAILED(rv)) continue;
nsXPIDLCString cidString;
rv = mRegistry->GetStringUTF8(progidKey, classIDValueName,
getter_Copies(cidString));
if (NS_FAILED(rv)) continue;
nsCID *aClass = new nsCID();
if (!aClass) continue; // Protect against out of memory.
if (!(aClass->Parse(cidString)))
{
delete aClass;
continue;
}
// put the {progid, Cid} mapping into our map
listProgIDs.push_back(progid2cid(progidString, *aClass));
delete aClass;
}
// ------------------------------------------------------------------------
NS_RELEASE(mRegistry);
return rv;
}