ExitStatus main(int argc, char * const * argv)
{
ExitStatus result = EX_OK;
KextstatArgs toolArgs;
CFDictionaryRef * kextInfoList = NULL; // must free
CFIndex count, i;
if (argv[0]) {
progname = argv[0];
}
/* Set the OSKext log callback right away.
*/
OSKextSetLogOutputFunction(&tool_log);
result = readArgs(argc, argv, &toolArgs);
if (result != EX_OK) {
if (result == kKextstatExitHelp) {
result = EX_OK;
}
goto finish;
}
toolArgs.runningKernelArch = OSKextGetRunningKernelArchitecture();
if (!toolArgs.runningKernelArch) {
result = EX_OSERR;
goto finish;
}
toolArgs.loadedKextInfo = OSKextCopyLoadedKextInfo(toolArgs.bundleIDs,
NULL /* all info */);
if (!toolArgs.loadedKextInfo) {
OSKextLog(/* kext */ NULL,
kOSKextLogErrorLevel | kOSKextLogGeneralFlag | kOSKextLogIPCFlag,
"Couldn't get list of loaded kexts from kernel.");
result = EX_OSERR;
goto finish;
}
if (!toolArgs.flagListOnly) {
printf("Index Refs Address ");
if (toolArgs.runningKernelArch->cputype & CPU_ARCH_ABI64) {
printf(" ");
}
printf("Size Wired ");
if (toolArgs.flagShowArchitecture) {
printf("Architecture ");
}
printf("Name (Version) <Linked Against>\n");
}
count = CFDictionaryGetCount(toolArgs.loadedKextInfo);
if (!count) {
goto finish;
}
kextInfoList = (CFDictionaryRef *)malloc(count * sizeof(CFDictionaryRef));
if (!kextInfoList) {
OSKextLogMemError();
result = EX_OSERR;
goto finish;
}
CFDictionaryGetKeysAndValues(toolArgs.loadedKextInfo, /* keys */ NULL,
(const void **)kextInfoList);
qsort(kextInfoList, count, sizeof(CFDictionaryRef), &compareKextInfo);
for (i = 0; i < count; i++) {
printKextInfo(kextInfoList[i], &toolArgs);
}
finish:
exit(result);
SAFE_FREE(kextInfoList);
return result;
}
int main(int argc, char * const argv[])
{
ExitStatus result = EX_SOFTWARE;
KctoolArgs toolArgs;
int kernelcache_fd = -1; // must close()
void * fat_header = NULL; // must unmapFatHeaderPage()
struct fat_arch * fat_arch = NULL;
CFDataRef rawKernelcache = NULL; // must release
CFDataRef kernelcacheImage = NULL; // must release
void * prelinkInfoSect = NULL;
const char * prelinkInfoBytes = NULL;
CFPropertyListRef prelinkInfoPlist = NULL; // must release
bzero(&toolArgs, sizeof(toolArgs));
/*****
* Find out what the program was invoked as.
*/
progname = rindex(argv[0], '/');
if (progname) {
progname++; // go past the '/'
} else {
progname = (char *)argv[0];
}
/* Set the OSKext log callback right away.
*/
OSKextSetLogOutputFunction(&tool_log);
/*****
* Process args & check for permission to load.
*/
result = readArgs(&argc, &argv, &toolArgs);
if (result != EX_OK) {
if (result == kKctoolExitHelp) {
result = EX_OK;
}
goto finish;
}
kernelcache_fd = open(toolArgs.kernelcachePath, O_RDONLY);
if (kernelcache_fd == -1) {
OSKextLog(/* kext */ NULL,
kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
"Can't open %s: %s.", toolArgs.kernelcachePath, strerror(errno));
result = EX_OSERR;
goto finish;
}
fat_header = mapAndSwapFatHeaderPage(kernelcache_fd);
if (!fat_header) {
OSKextLog(/* kext */ NULL,
kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
"Can't map %s: %s.", toolArgs.kernelcachePath, strerror(errno));
result = EX_OSERR;
goto finish;
}
fat_arch = getFirstFatArch(fat_header);
if (fat_arch && !toolArgs.archInfo) {
toolArgs.archInfo = NXGetArchInfoFromCpuType(fat_arch->cputype, fat_arch->cpusubtype);
}
rawKernelcache = readMachOSliceForArch(toolArgs.kernelcachePath, toolArgs.archInfo,
/* checkArch */ FALSE);
if (!rawKernelcache) {
OSKextLog(/* kext */ NULL,
kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
"Can't read arch %s from %s.", toolArgs.archInfo->name, toolArgs.kernelcachePath);
goto finish;
}
if (MAGIC32(CFDataGetBytePtr(rawKernelcache)) == OSSwapHostToBigInt32('comp')) {
kernelcacheImage = uncompressPrelinkedSlice(rawKernelcache);
if (!kernelcacheImage) {
OSKextLog(/* kext */ NULL,
kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
"Can't uncompress kernelcache slice.");
goto finish;
}
} else {
kernelcacheImage = CFRetain(rawKernelcache);
}
toolArgs.kernelcacheImageBytes = CFDataGetBytePtr(kernelcacheImage);
if (ISMACHO64(MAGIC32(toolArgs.kernelcacheImageBytes))) {
prelinkInfoSect = (void *)macho_get_section_by_name_64(
(struct mach_header_64 *)toolArgs.kernelcacheImageBytes,
"__PRELINK_INFO", "__info");
} else {
prelinkInfoSect = (void *)macho_get_section_by_name(
(struct mach_header *)toolArgs.kernelcacheImageBytes,
"__PRELINK_INFO", "__info");
}
if (!prelinkInfoSect) {
OSKextLog(/* kext */ NULL,
kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
"Can't find prelink info section.");
goto finish;
}
if (ISMACHO64(MAGIC32(toolArgs.kernelcacheImageBytes))) {
prelinkInfoBytes = ((char *)toolArgs.kernelcacheImageBytes) +
((struct section_64 *)prelinkInfoSect)->offset;
} else {
prelinkInfoBytes = ((char *)toolArgs.kernelcacheImageBytes) +
((struct section *)prelinkInfoSect)->offset;
}
toolArgs.kernelcacheInfoPlist = (CFPropertyListRef)IOCFUnserialize(prelinkInfoBytes,
kCFAllocatorDefault, /* options */ 0, /* errorString */ NULL);
if (!toolArgs.kernelcacheInfoPlist) {
OSKextLog(/* kext */ NULL,
kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
"Can't unserialize prelink info.");
goto finish;
}
result = printKextInfo(&toolArgs);
if (result != EX_OK) {
goto finish;
}
result = EX_OK;
finish:
SAFE_RELEASE(toolArgs.kernelcacheInfoPlist);
SAFE_RELEASE(kernelcacheImage);
SAFE_RELEASE(rawKernelcache);
if (fat_header) {
unmapFatHeaderPage(fat_header);
}
if (kernelcache_fd != -1) {
close(kernelcache_fd);
}
return result;
}
int main(int argc, char * const * argv)
{
ExitStatus result = EX_SOFTWARE;
KcgenArgs toolArgs;
Boolean fatal = false;
/*****
* Find out what the program was invoked as.
*/
progname = rindex(argv[0], '/');
if (progname) {
progname++; // go past the '/'
} else {
progname = (char *)argv[0];
}
/* Set the OSKext log callback right away.
*/
OSKextSetLogOutputFunction(&tool_log);
/* Make the library not sort opened kexts by version for bundle ID lookups.
*/
_OSKextSetStrictRecordingByLastOpened(TRUE);
/*****
* Check if we were spawned by kextd, set up straightaway
* for service log filtering, and hook up to ASL.
*/
if (getenv("KEXTD_SPAWNED")) {
OSKextSetLogFilter(kDefaultServiceLogFilter | kOSKextLogKextOrGlobalMask,
/* kernel? */ false);
OSKextSetLogFilter(kDefaultServiceLogFilter | kOSKextLogKextOrGlobalMask,
/* kernel? */ true);
tool_openlog("com.apple.kcgen");
}
/*****
* Process args & check for permission to load.
*/
result = readArgs(&argc, &argv, &toolArgs);
if (result != EX_OK) {
if (result == kKcgenExitHelp) {
result = EX_OK;
}
goto finish;
}
result = checkArgs(&toolArgs);
if (result != EX_OK) {
goto finish;
}
/* From here on out the default exit status is ok.
*/
result = EX_OK;
/* The whole point of this program is to update caches, so let's not
* try to read any (we'll briefly turn this back on when checking them).
*/
OSKextSetUsesCaches(false);
/* If we're compressing the prelinked kernel, take care of that here
* and exit.
*/
if (toolArgs.prelinkedKernelPath && !CFArrayGetCount(toolArgs.argURLs) &&
(toolArgs.compress || toolArgs.uncompress))
{
result = compressPrelinkedKernel(toolArgs.prelinkedKernelPath, toolArgs.compress);
goto finish;
}
/*****
* Read the kexts we'll be working with; first the set of all kexts, then
* the repository and named kexts for use with mkext-creation flags.
*/
if (toolArgs.printTestResults) {
OSKextSetRecordsDiagnostics(kOSKextDiagnosticsFlagAll);
}
toolArgs.allKexts = OSKextCreateKextsFromURLs(kCFAllocatorDefault, toolArgs.argURLs);
if (!toolArgs.allKexts || !CFArrayGetCount(toolArgs.allKexts)) {
OSKextLog(/* kext */ NULL,
kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
"Error - no kernel extensions found.");
result = EX_SOFTWARE;
goto finish;
}
toolArgs.repositoryKexts = OSKextCreateKextsFromURLs(kCFAllocatorDefault,
toolArgs.repositoryURLs);
toolArgs.namedKexts = OSKextCreateKextsFromURLs(kCFAllocatorDefault,
toolArgs.namedKextURLs);
if (!toolArgs.repositoryKexts || !toolArgs.namedKexts) {
OSKextLog(/* kext */ NULL,
kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
"Error - failed to read extensions.");
result = EX_SOFTWARE;
goto finish;
}
if (result != EX_OK) {
goto finish;
}
if (toolArgs.prelinkedKernelPath) {
result = createPrelinkedKernel(&toolArgs);
if (result != EX_OK) {
goto finish;
}
}
finish:
/* We're actually not going to free anything else because we're exiting!
*/
exit(result);
SAFE_RELEASE(toolArgs.kextIDs);
SAFE_RELEASE(toolArgs.argURLs);
SAFE_RELEASE(toolArgs.repositoryURLs);
SAFE_RELEASE(toolArgs.namedKextURLs);
SAFE_RELEASE(toolArgs.allKexts);
SAFE_RELEASE(toolArgs.repositoryKexts);
SAFE_RELEASE(toolArgs.namedKexts);
SAFE_RELEASE(toolArgs.kernelFile);
SAFE_RELEASE(toolArgs.symbolDirURL);
SAFE_FREE(toolArgs.prelinkedKernelPath);
SAFE_FREE(toolArgs.kernelPath);
return result;
}
