bool PE::_parse_hint_name_table(pimport_lookup_table import) const
{
int size_to_read = (get_architecture() == PE::x86 ? 4 : 8);
// Read the HINT/NAME TABLE if applicable. Check the most significant byte of AddressOfData to
// see if the import is by name or ordinal. For PE32+, AddressOfData is a uint64.
boost::uint64_t mask = (size_to_read == 8 ? 0x8000000000000000 : 0x80000000);
if (!(import->AddressOfData & mask))
{
// Import by name. Read the HINT/NAME table. For both PE32 and PE32+, its RVA is stored
// in bits 30-0 of AddressOfData.
unsigned int table_offset = _rva_to_offset(import->AddressOfData & 0x7FFFFFFF);
if (table_offset == 0)
{
PRINT_ERROR << "Could not reach the HINT/NAME table." << std::endl;
return false;
}
long saved_offset = ftell(_file_handle.get());
if (saved_offset == -1 || fseek(_file_handle.get(), table_offset, SEEK_SET) || 2 != fread(&(import->Hint), 1, 2, _file_handle.get()))
{
PRINT_ERROR << "Could not read a HINT/NAME hint." << std::endl;
return false;
}
import->Name = utils::read_ascii_string(_file_handle.get());
//TODO: Demangle the import name
// Go back to the import lookup table.
if (fseek(_file_handle.get(), saved_offset, SEEK_SET)) {
return false;
}
}
return true;
}
bool PE::_parse_import_lookup_table(unsigned int offset, pImportedLibrary library) const
{
if (!offset || fseek(_file_handle.get(), offset, SEEK_SET))
{
PRINT_ERROR << "Could not reach an IMPORT_LOOKUP_TABLE." << std::endl;
return false;
}
while (true) // We stop at the first NULL IMPORT_LOOKUP_TABLE
{
pimport_lookup_table import = boost::make_shared<import_lookup_table>();
import->AddressOfData = 0;
import->Hint = 0;
// The field has a size of 8 for x64 PEs
int size_to_read = (get_architecture() == x86 ? 4 : 8);
if (size_to_read != fread(&(import->AddressOfData), 1, size_to_read, _file_handle.get()))
{
PRINT_ERROR << "Could not read the IMPORT_LOOKUP_TABLE." << std::endl;
return false;
}
// Exit condition
if (import->AddressOfData == 0) {
break;
}
if (!_parse_hint_name_table(import)) {
return false;
}
library->add_import(import);
}
return true;
}
void
AddOnManager::RegisterAddOns()
{
// Check if add-ons are already registered.
if (!fReaderList.IsEmpty() || !fWriterList.IsEmpty()
|| !fDecoderList.IsEmpty() || !fEncoderList.IsEmpty()) {
return;
}
char** directories = NULL;
size_t directoryCount = 0;
if (find_paths_etc(get_architecture(), B_FIND_PATH_ADD_ONS_DIRECTORY,
"media/plugins", B_FIND_PATH_EXISTING_ONLY, &directories,
&directoryCount) != B_OK) {
return;
}
MemoryDeleter directoriesDeleter(directories);
BPath path;
for (uint i = 0; i < directoryCount; i++) {
BDirectory directory;
if (directory.SetTo(directories[i]) == B_OK) {
entry_ref ref;
while(directory.GetNextRef(&ref) == B_OK)
_RegisterAddOn(ref);
}
}
}
status_t
AddOnManager::GetReaders(entry_ref* outRefs, int32* outCount,
int32 maxCount)
{
BAutolock locker(fLock);
RegisterAddOns();
*outCount = 0;
// See GetDecoderForFormat() for why we need to scan the list by path.
char** directories = NULL;
size_t directoryCount = 0;
if (find_paths_etc(get_architecture(), B_FIND_PATH_ADD_ONS_DIRECTORY,
"media/plugins", B_FIND_PATH_EXISTING_ONLY, &directories,
&directoryCount) != B_OK) {
printf("AddOnManager::GetReaders: failed to locate plugins\n");
return B_ENTRY_NOT_FOUND;
}
MemoryDeleter directoriesDeleter(directories);
BPath path;
for (uint i = 0; i < directoryCount; i++) {
path.SetTo(directories[i]);
_GetReaders(path, outRefs, outCount, maxCount);
}
return B_OK;
}
status_t
AddOnManager::GetDecoderForFormat(entry_ref* _decoderRef,
const media_format& format)
{
if ((format.type == B_MEDIA_ENCODED_VIDEO
|| format.type == B_MEDIA_ENCODED_AUDIO
|| format.type == B_MEDIA_MULTISTREAM)
&& format.Encoding() == 0) {
return B_MEDIA_BAD_FORMAT;
}
if (format.type == B_MEDIA_NO_TYPE || format.type == B_MEDIA_UNKNOWN_TYPE)
return B_MEDIA_BAD_FORMAT;
BAutolock locker(fLock);
RegisterAddOns();
// Since the list of decoders is unsorted, we need to search for
// a decoder by add-on directory, in order to maintain the shadowing
// of system add-ons by user add-ons, in case they offer decoders
// for the same format.
char** directories = NULL;
size_t directoryCount = 0;
if (find_paths_etc(get_architecture(), B_FIND_PATH_ADD_ONS_DIRECTORY,
"media/plugins", B_FIND_PATH_EXISTING_ONLY, &directories,
&directoryCount) != B_OK) {
printf("AddOnManager::GetDecoderForFormat: failed to locate plugins\n");
return B_ENTRY_NOT_FOUND;
}
MemoryDeleter directoriesDeleter(directories);
BPath path;
for (uint i = 0; i < directoryCount; i++) {
path.SetTo(directories[i]);
if (_FindDecoder(format, path, _decoderRef))
return B_OK;
}
return B_ENTRY_NOT_FOUND;
}
status_t
AddOnManager::GetEncoderForFormat(entry_ref* _encoderRef,
const media_format& outputFormat)
{
if ((outputFormat.type == B_MEDIA_RAW_VIDEO
|| outputFormat.type == B_MEDIA_RAW_AUDIO)) {
return B_MEDIA_BAD_FORMAT;
}
if (outputFormat.type == B_MEDIA_NO_TYPE
|| outputFormat.type == B_MEDIA_UNKNOWN_TYPE) {
return B_MEDIA_BAD_FORMAT;
}
BAutolock locker(fLock);
RegisterAddOns();
char** directories = NULL;
size_t directoryCount = 0;
if (find_paths_etc(get_architecture(), B_FIND_PATH_ADD_ONS_DIRECTORY,
"media/plugins", B_FIND_PATH_EXISTING_ONLY, &directories,
&directoryCount) != B_OK) {
printf("AddOnManager::GetDecoderForFormat: failed to locate plugins\n");
return B_ENTRY_NOT_FOUND;
}
MemoryDeleter directoriesDeleter(directories);
BPath path;
for (uint i = 0; i < directoryCount; i++) {
path.SetTo(directories[i]);
if (_FindEncoder(outputFormat, path, _encoderRef))
return B_OK;
}
return B_ENTRY_NOT_FOUND;
}
/**
* initializes cpuinfo-struct
* @param print detection-summary is written to stdout when !=0
*/
void init_cpuinfo(cpu_info_t *cpuinfo,int print)
{
unsigned int i;
char output[_HW_DETECT_MAX_OUTPUT];
/* initialize data structure */
memset(cpuinfo,0,sizeof(cpu_info_t));
strcpy(cpuinfo->architecture,"unknown\0");
strcpy(cpuinfo->vendor,"unknown\0");
strcpy(cpuinfo->model_str,"unknown\0");
cpuinfo->num_cpus = num_cpus();
get_architecture(cpuinfo->architecture, sizeof(cpuinfo->architecture));
get_cpu_vendor(cpuinfo->vendor, sizeof(cpuinfo->vendor));
get_cpu_name(cpuinfo->model_str, sizeof(cpuinfo->model_str));
cpuinfo->family = get_cpu_family();
cpuinfo->model = get_cpu_model();
cpuinfo->stepping = get_cpu_stepping();
cpuinfo->num_cores_per_package = num_cores_per_package();
cpuinfo->num_threads_per_core = num_threads_per_core();
cpuinfo->num_packages = num_packages();
cpuinfo->clockrate = get_cpu_clockrate(1, 0);
/* setup supported feature list*/
if(!strcmp(cpuinfo->architecture,"x86_64")) cpuinfo->features |= X86_64;
if (feature_available("SMT")) cpuinfo->features |= SMT;
if (feature_available("FPU")) cpuinfo->features |= FPU;
if (feature_available("MMX")) cpuinfo->features |= MMX;
if (feature_available("MMX_EXT")) cpuinfo->features |= MMX_EXT;
if (feature_available("SSE")) cpuinfo->features |= SSE;
if (feature_available("SSE2")) cpuinfo->features |= SSE2;
if (feature_available("SSE3")) cpuinfo->features |= SSE3;
if (feature_available("SSSE3")) cpuinfo->features |= SSSE3;
if (feature_available("SSE4.1")) cpuinfo->features |= SSE4_1;
if (feature_available("SSE4.2")) cpuinfo->features |= SSE4_2;
if (feature_available("SSE4A")) cpuinfo->features |= SSE4A;
if (feature_available("ABM")) cpuinfo->features |= ABM;
if (feature_available("POPCNT")) cpuinfo->features |= POPCNT;
if (feature_available("AVX")) cpuinfo->features |= AVX;
if (feature_available("AVX2")) cpuinfo->features |= AVX2;
if (feature_available("FMA")) cpuinfo->features |= FMA;
if (feature_available("FMA4")) cpuinfo->features |= FMA4;
if (feature_available("AES")) cpuinfo->features |= AES;
if (feature_available("AVX512")) cpuinfo->features |= AVX512;
/* determine cache details */
for (i=0; i<(unsigned int)num_caches(0); i++)
{
cpuinfo->Cache_shared[cache_level(0,i)-1]=cache_shared(0,i);
cpuinfo->Cacheline_size[cache_level(0,i)-1]=cacheline_length(0,i);
if (cpuinfo->Cachelevels < (unsigned int)cache_level(0,i)) { cpuinfo->Cachelevels = cache_level(0,i); }
switch (cache_type(0,i))
{
case UNIFIED_CACHE: {
cpuinfo->Cache_unified[cache_level(0,i)-1]=1;
cpuinfo->U_Cache_Size[cache_level(0,i)-1]=cache_size(0,i);
cpuinfo->U_Cache_Sets[cache_level(0,i)-1]=cache_assoc(0,i);
break;
}
case DATA_CACHE: {
cpuinfo->Cache_unified[cache_level(0,i)-1]=0;
cpuinfo->D_Cache_Size[cache_level(0,i)-1]=cache_size(0,i);
cpuinfo->D_Cache_Sets[cache_level(0,i)-1]=cache_assoc(0,i);
break;
}
case INSTRUCTION_CACHE: {
cpuinfo->Cache_unified[cache_level(0,i)-1]=0;
cpuinfo->I_Cache_Size[cache_level(0,i)-1]=cache_size(0,i);
cpuinfo->I_Cache_Sets[cache_level(0,i)-1]=cache_assoc(0,i);
break;
}
default:
break;
}
}
/* print a summary */
if (print)
{
fflush(stdout);
printf("\n system summary:\n");
if(cpuinfo->num_packages) printf(" number of processors: %i\n",cpuinfo->num_packages);
if(cpuinfo->num_cores_per_package) printf(" number of cores per package: %i\n",cpuinfo->num_cores_per_package);
if(cpuinfo->num_threads_per_core) printf(" number of threads per core: %i\n",cpuinfo->num_threads_per_core);
if(cpuinfo->num_cpus) printf(" total number of threads: %i\n",cpuinfo->num_cpus);
printf("\n processor characteristics:\n");
printf(" architecture: %s\n",cpuinfo->architecture);
printf(" vendor: %s\n",cpuinfo->vendor);
printf(" processor-name: %s\n",cpuinfo->model_str);
printf(" model: Family %i, Model %i, Stepping %i\n",cpuinfo->family,cpuinfo->model,cpuinfo->stepping);
printf(" frequency: %llu MHz\n",cpuinfo->clockrate/1000000);
fflush(stdout);
printf(" supported features:\n -");
if(cpuinfo->features&X86_64) printf(" X86_64");
if(cpuinfo->features&FPU) printf(" FPU");
if(cpuinfo->features&MMX) printf(" MMX");
if(cpuinfo->features&MMX_EXT) printf(" MMX_EXT");
if(cpuinfo->features&SSE) printf(" SSE");
if(cpuinfo->features&SSE2) printf(" SSE2");
if(cpuinfo->features&SSE3) printf(" SSE3");
if(cpuinfo->features&SSSE3) printf(" SSSE3");
if(cpuinfo->features&SSE4_1) printf(" SSE4.1");
if(cpuinfo->features&SSE4_2) printf(" SSE4.2");
if(cpuinfo->features&SSE4A) printf(" SSE4A");
if(cpuinfo->features&POPCNT) printf(" POPCNT");
if(cpuinfo->features&AVX) printf(" AVX");
if(cpuinfo->features&AVX2) printf(" AVX2");
if(cpuinfo->features&AVX512) printf(" AVX512");
if(cpuinfo->features&FMA) printf(" FMA");
if(cpuinfo->features&FMA4) printf(" FMA4");
if(cpuinfo->features&AES) printf(" AES");
if(cpuinfo->features&SMT) printf(" SMT");
printf(" \n");
if(cpuinfo->Cachelevels)
{
printf(" Caches:\n");
for(i = 0; i < (unsigned int)num_caches(0); i++)
{
snprintf(output,sizeof(output),"n/a");
if (cache_info(0, i, output, sizeof(output)) != -1) printf(" - %s\n",output);
}
}
}
fflush(stdout);
}
