bool ibanBicStoragePlugin::setupDatabase(QSqlDatabase connection) { // Get current version QSqlQuery query = QSqlQuery(connection); query.prepare("SELECT versionMajor FROM kmmPluginInfo WHERE iid = ?"); query.bindValue(0, iid()); if (!query.exec()) { qWarning("Could not execute query for ibanBicStoragePlugin: %s", qPrintable(query.lastError().text())); return false; } int currentVersion = 0; if (query.next()) currentVersion = query.value(0).toInt(); // Create database in it's most recent version if version is 0 // (version 0 means the database was not installed) if (currentVersion == 0) { // If the database is recreated the table may be still there. So drop it if needed. No error handling needed // as this step is not necessary - only the creation is important. query.exec("DROP TABLE IF EXISTS kmmIbanBic;"); if (!query.exec( "CREATE TABLE kmmIbanBic (" " id varchar(32) NOT NULL PRIMARY KEY REFERENCES kmmPayeeIdentifier( id ) ON DELETE CASCADE ON UPDATE CASCADE," " iban varchar(32)," " bic char(11) CHECK(length(bic) = 11 OR bic IS NULL)," " name text" " );" )) { qWarning("Could not create table for ibanBicStoragePlugin: %s", qPrintable(query.lastError().text())); return false; } query.prepare("INSERT INTO kmmPluginInfo (iid, versionMajor, versionMinor, uninstallQuery) VALUES(?, ?, ?, ?)"); query.bindValue(0, iid()); query.bindValue(1, 1); query.bindValue(2, 0); query.bindValue(3, "DROP TABLE kmmIbanBic;"); if (query.exec()) return true; qWarning("Could not save plugin info for ibanBicStoragePlugin (%s): %s", qPrintable(iid()), qPrintable(query.lastError().text())); return false; } // Check if version is valid with this plugin switch (currentVersion) { case 1: return true; } return false; }
JNIEXPORT jlong JNICALL Java_com4j_Native_getErrorInfo( JNIEnv* env, jclass __unused__, jlong pComObject, jlong iid1, jlong iid2) { MyGUID iid(iid1,iid2); try { ISupportErrorInfoPtr p(reinterpret_cast<IUnknown*>(pComObject)); if(p==NULL) return 0; // not supported HRESULT hr = p->InterfaceSupportsErrorInfo(iid); if(FAILED(hr)) { error(env,__FILE__,__LINE__,hr,"ISupportErrorInfo::InterfaceSupportsErrorInfo failed"); return 0; } if(hr!=S_OK) return 0; // not supported IErrorInfo* pError; hr = GetErrorInfo(0,&pError); if(FAILED(hr)) { error(env,__FILE__,__LINE__,hr,"GetErrorInfo failed"); return 0; } // return the pointer return reinterpret_cast<jlong>(pError); } catch (...) { // an exception occured. This might happen, if the automation server is not available due to a crash. return 0; } return 0; }
static PyObject *PyCurrentItem(PyObject *self, PyObject *args) { PyObject *obIID = NULL; if (!PyArg_ParseTuple(args, "|O:CurrentItem", &obIID)) return NULL; nsIID iid(NS_GET_IID(nsISupports)); if (obIID != NULL && !Py_nsIID::IIDFromPyObject(obIID, &iid)) return NULL; nsIEnumerator *pI = GetI(self); if (pI==NULL) return NULL; nsISupports *pRet = nsnull; nsresult r; Py_BEGIN_ALLOW_THREADS; r = pI->CurrentItem(&pRet); Py_END_ALLOW_THREADS; if ( NS_FAILED(r) ) return PyXPCOM_BuildPyException(r); if (obIID) { nsISupports *temp; Py_BEGIN_ALLOW_THREADS; r = pRet->QueryInterface(iid, (void **)&temp); pRet->Release(); Py_END_ALLOW_THREADS; if ( NS_FAILED(r) ) { return PyXPCOM_BuildPyException(r); } pRet = temp; } return Py_nsISupports::PyObjectFromInterface(pRet, iid, PR_FALSE); }
// Also saves sample information void writeMDS(const std::string& file_name, const std::vector<Sample>& sample_names, const arma::mat& MDS) { if (MDS.n_rows == sample_names.size()) { MDS.save(file_name, arma::hdf5_binary); std::string sample_file_name = file_name + sample_suffix; std::ofstream sample_names_file(sample_file_name.c_str()); // Write out the sample name order if (!sample_names_file) { std::cerr << "Could not write used sample names to " << sample_file_name << std::endl; } else { for (auto sample_it = sample_names.begin(); sample_it != sample_names.end(); ++sample_it) { sample_names_file << sample_it->iid() << std::endl; } } } else { throw std::logic_error("When writing matrix to " + file_name + " the number samples in the .pheno file did not match the number of columns or rows"); } }
SeasideCache::CacheItem *SeasideCache::itemById(const QContactId &id, bool) { quint32 iid(internalId(id)); if (instancePtr->m_cacheIndices.contains(iid)) { return &instancePtr->m_cache[instancePtr->m_cacheIndices[iid]]; } return 0; }
QContact SeasideCache::contactById(const ContactIdType &id) { #ifdef USING_QTPIM quint32 iid(internalId(id)); return instancePtr->m_cache[instancePtr->m_cacheIndices[iid]].contact; #else return instancePtr->m_cache[id - 1].contact; #endif }
void SthenoCore::createLocalServiceReplica( UUIDPtr& sid, ServiceParamsPtr& params, ServiceAbstractPtr& sPtr) throw (RuntimeException&, ServiceException&) { if (!isValid()) { throw RuntimeException(RuntimeException::INVALID_RUNTIME); } FaultTolerancePtr ftToleranceSvc; try { m_overlay->getFaultTolerance(ftToleranceSvc); } catch (OverlayException& ex) { throw RuntimeException(RuntimeException::INVALID_OVERLAY); } UUIDPtr iid(UUID::generateUUID()); createServiceInstance(sid, iid, sPtr); //QoSResources* qos = sPtr->calculateQoSResources(params); printf("INFO: createLocalServiceReplica() - SID=%s before open service!\n", sid->toString().c_str()); QoSManagerInterface* qosManager = 0; if (m_reservationFlag) { UUIDPtr serviceCgroupUUID(UUID::generateUUID()); String path = "service_" + sid->toString() + "_" + serviceCgroupUUID->toString(); qosManager = m_serviceQosManager->createSubDomainQoSManager(path, 200, m_runtimePeriod); //String ftPath = "/FT"; String ftPath = Cgroup::getSep(); ftPath += "FT"; //HierarchicalPath::appendPaths(path, "/FT"); QoSManagerInterface* qosFTManager = 0; qosFTManager = qosManager->createSubDomainQoSManager(ftPath, 100, m_runtimePeriod); String servicePath = Cgroup::getSep(); servicePath += "service"; //HierarchicalPath::appendPaths(path, "/service"); QoSManagerInterface* qosServiceManager = 0; qosServiceManager = qosManager->createSubDomainQoSManager(servicePath, 100, m_runtimePeriod); //String path = "service_" + sid->toString() + "_" + serviceCgroupUUID->toString(); //qosManager = m_serviceQosManager->createSubDomainQoSManager(path, 10000, QoSManagerInterface::DEFAULT_PERIOD); } sPtr->open(params, ServiceAbstract::FT_REPLICA, qosManager); printf("INFO: createLocalServiceReplica() SID=%s after open service!\n", sid->toString().c_str()); ServiceInstanceInfoPtr info; //UUIDPtr iid = sPtr->getIID(); this->getInstanceOfService(sid, iid, info); MeshPtr meshPtr; try { getOverlay()->getMesh(meshPtr); } catch (OverlayException& ex) { throw RuntimeException(RuntimeException::INVALID_OVERLAY); } meshPtr->onServiceCreation(info); }
JNIEXPORT jlong JNICALL Java_com4j_Native_queryInterface( JNIEnv* env, jclass __unused__, jlong pComObject, jlong iid1, jlong iid2 ) { MyGUID iid(iid1,iid2); void* p; HRESULT hr = toComObject(pComObject)->QueryInterface(iid,&p); if(FAILED(hr)) { return 0; } return reinterpret_cast<jlong>(p); }
SeasideCache::CacheItem *SeasideCache::itemById(const ContactIdType &id, bool) { #ifdef USING_QTPIM quint32 iid(internalId(id)); if (instancePtr->m_cacheIndices.contains(iid)) { return &instancePtr->m_cache[instancePtr->m_cacheIndices[iid]]; } #else if (id != 0 && id <= instancePtr->m_cache.count()) { return &instancePtr->m_cache[id - 1]; } #endif return 0; }
JNIEXPORT jlong JNICALL Java_com4j_Native_createInstance( JNIEnv* env, jclass __unused__, jstring _progId, jint clsctx, jlong iid1, jlong iid2 ) { MyGUID iid(iid1,iid2); CLSID clsid; HRESULT hr; JString progId(env,_progId); hr = CLSIDFromProgID(progId,&clsid); if(FAILED(hr)) { if(FAILED(CLSIDFromString( const_cast<LPOLESTR>(LPCOLESTR(progId)),&clsid))) { error(env,__FILE__,__LINE__,hr,"Unrecognized CLSID"); return 0; } } void* p; if(clsctx&(CLSCTX_LOCAL_SERVER|CLSCTX_REMOTE_SERVER)) { IUnknown* pUnk = NULL; hr = CoCreateInstance(clsid,NULL,clsctx,__uuidof(IUnknown),(void**)&pUnk); if(FAILED(hr)) { error(env,__FILE__,__LINE__,hr,"CoCreateInstance failed"); return 0; } hr = OleRun(pUnk); if(FAILED(hr)) { pUnk->Release(); error(env,__FILE__,__LINE__,hr,"OleRun failed"); return 0; } hr = pUnk->QueryInterface(iid,&p); pUnk->Release(); if(FAILED(hr)) { error(env,__FILE__,__LINE__,hr,"QueryInterface failed"); return 0; } } else { // just the plain CoCreateInstance hr = CoCreateInstance(clsid,NULL,clsctx,iid,&p); if(FAILED(hr)) { error(env,__FILE__,__LINE__,hr,"CoCreateInstance failed"); return 0; } } return reinterpret_cast<jlong>(p); }
void SthenoCore::createReplicationGroup( OverlayPeerInfoPtr& primary, list<OverlayPeerInfoPtr>& replicas, UUIDPtr& rgid, UUIDPtr& sid, ServiceParamsPtr& params ) throw (ServiceException&) { if (!isValid()) { throw RuntimeException(RuntimeException::INVALID_RUNTIME); } ServiceAbstractPtr sPtr; FaultTolerancePtr ftToleranceSvc; try { m_overlay->getFaultTolerance(ftToleranceSvc); } catch (OverlayException& ex) { throw RuntimeException(RuntimeException::INVALID_OVERLAY); } printf("==========================> SID=%s FT params=%p %p\n", sid->toString().c_str(), params->getFTParams().get(), params->getQuerySpecializationBlob()); if (!params->getFTParams().null()) { UUIDPtr iid(UUID::generateUUID()); createServiceInstance(sid, iid, sPtr); UInt serviceOverallQoS = SERVICE_DEFAULT_QOS * 2; //5000; //UInt serviceFTQoS = 50000; //50000; //UInt serviceQoS = 50000; //50000; //total=31K //+1 = 46K //QoS UUIDPtr serviceCgroupUUID(UUID::generateUUID()); String path = "service_" + sid->toString() + "_" + serviceCgroupUUID->toString(); QoSManagerInterface* qosManager = 0; if (m_reservationFlag) { //qosManager = m_serviceQosManager->createSubDomainQoSManager(path, serviceOverallQoS, m_runtimePeriod); qosManager = m_runtimeQoSManager; } QoSManagerInterface* qosFTManager = qosManager; /*String ftPath = Cgroup::getSep(); ftPath += "FT"; //HierarchicalPath::appendPaths(path, "/FT"); if (m_reservationFlag) { qosFTManager = qosManager->createSubDomainQoSManager(ftPath, serviceFTQoS, m_runtimePeriod); }*/ QoSManagerInterface* qosServiceManager = qosManager; /*String servicePath = Cgroup::getSep(); servicePath += "service"; //HierarchicalPath::appendPaths(path, "/service"); if (m_reservationFlag) { qosServiceManager = qosManager->createSubDomainQoSManager(servicePath, serviceQoS, m_runtimePeriod); }*/ ftToleranceSvc->createReplicationGroup(sPtr, params, rgid, primary, replicas, qosFTManager); sPtr->open(params, ServiceAbstract::FT_REPLICA, qosServiceManager); //free meta qos manager /*if (qosManager != 0) { delete qosManager; }*/ ServiceInstanceInfoPtr info; //UUIDPtr iid = sPtr->getIID(); this->getInstanceOfService(sid, iid, info); MeshPtr meshPtr; try { getOverlay()->getMesh(meshPtr); } catch (OverlayException& ex) { throw RuntimeException(RuntimeException::INVALID_OVERLAY); } meshPtr->onServiceCreation(info); } else { throw ServiceException(ServiceException::INVALID_FT_PARAMS); } }
// A method added for Python performance if you really need // it. Allows you to fetch a block of objects in one // hit, allowing the loop to remain implemented in C. static PyObject *PyFetchBlock(PyObject *self, PyObject *args) { PyObject *obIID = NULL; int n_wanted; int n_fetched = 0; if (!PyArg_ParseTuple(args, "i|O:FetchBlock", &n_wanted, &obIID)) return NULL; nsIID iid(NS_GET_IID(nsISupports)); if (obIID != NULL && !Py_nsIID::IIDFromPyObject(obIID, &iid)) return NULL; nsIEnumerator *pI = GetI(self); if (pI==NULL) return NULL; // We want to fetch with the thread-lock released, // but this means we can not append to the PyList nsISupports **fetched = new nsISupports*[n_wanted]; if (fetched==nsnull) { PyErr_NoMemory(); return NULL; } memset(fetched, 0, sizeof(nsISupports *) * n_wanted); nsresult r = NS_OK; Py_BEGIN_ALLOW_THREADS; for (;n_fetched<n_wanted;) { nsISupports *pNew; r = pI->CurrentItem(&pNew); if (NS_FAILED(r)) { r = 0; // Normal enum end break; } if (obIID) { nsISupports *temp; r = pNew->QueryInterface(iid, (void **)&temp); pNew->Release(); if ( NS_FAILED(r) ) { break; } pNew = temp; } fetched[n_fetched] = pNew; n_fetched++; // must increment before breaking out. if (NS_FAILED(pI->Next())) break; // not an error condition. } Py_END_ALLOW_THREADS; PyObject *ret; if (NS_SUCCEEDED(r)) { ret = PyList_New(n_fetched); if (ret) for (int i=0;i<n_fetched;i++) { PyObject *new_ob = Py_nsISupports::PyObjectFromInterface(fetched[i], iid, PR_FALSE); PyList_SET_ITEM(ret, i, new_ob); } } else ret = PyXPCOM_BuildPyException(r); if ( ret == NULL ) { // Free the objects we consumed. for (int i=0;i<n_fetched;i++) fetched[i]->Release(); } delete [] fetched; return ret; }
QContact SeasideCache::contactById(const QContactId &id) { quint32 iid(internalId(id)); return instancePtr->m_cache[instancePtr->m_cacheIndices[iid]].contact; }
bool CalendarTemplateElement::loadFromRecord( const Record& record, util::Env& env ) { bool result(false); if(record.isDefined(TABLE_COL_ID)) { RegistryKeyType value(record.getDefault<RegistryKeyType>(TABLE_COL_ID, 0)); if(value != getKey()) { result = true; setKey(value); } } // Rank if(record.isDefined(CalendarTemplateElementTableSync::COL_RANK)) { size_t value( record.getDefault<size_t>(CalendarTemplateElementTableSync::COL_RANK, 0) ); if(value != getRank()) { result = true; setRank(value); } } // Min date if(record.isDefined(CalendarTemplateElementTableSync::COL_MIN_DATE)) { date value(neg_infin); if(!record.get<string>(CalendarTemplateElementTableSync::COL_MIN_DATE).empty()) { try { value = from_string(record.get<string>(CalendarTemplateElementTableSync::COL_MIN_DATE)); } catch(...) { } } if(value != getMinDate()) { result = true; setMinDate(value); } } // Max date if(record.isDefined(CalendarTemplateElementTableSync::COL_MAX_DATE)) { date value(pos_infin); if(!record.get<string>(CalendarTemplateElementTableSync::COL_MAX_DATE).empty()) { try { value = from_string(record.get<string>(CalendarTemplateElementTableSync::COL_MAX_DATE)); } catch(...) { } } if(value != getMaxDate()) { result = true; setMaxDate(value); } } // Days modulo if(record.isDefined(CalendarTemplateElementTableSync::COL_INTERVAL)) { days value( record.getDefault<long>(CalendarTemplateElementTableSync::COL_INTERVAL, 0) ); if(value != getStep()) { result = true; setStep(value); } } // Operation if(record.isDefined(CalendarTemplateElementTableSync::COL_POSITIVE)) { Operation value( static_cast<Operation>( record.getDefault<int>(CalendarTemplateElementTableSync::COL_POSITIVE, 0) ) ); if(value != getOperation()) { result = true; setOperation(value); } } // Included calendar // if(linkLevel > FIELDS_ONLY_LOAD_LEVEL) { if(record.isDefined(CalendarTemplateElementTableSync::COL_INCLUDE_ID)) { CalendarTemplate* value(NULL); RegistryKeyType iid( record.getDefault<RegistryKeyType>( CalendarTemplateElementTableSync::COL_INCLUDE_ID, 0 ) ); if(iid > 0) try { value = CalendarTemplateTableSync::GetEditable(iid, env).get(); } catch (ObjectNotFoundException<CalendarTemplate> e) { Log::GetInstance().warn("Data corrupted in " + CalendarTemplateElementTableSync::TABLE.NAME + "/" + CalendarTemplateElementTableSync::COL_INCLUDE_ID, e); } if(value != getInclude()) { result = true; setInclude(value); } } } // Link with calendar template // if(linkLevel == UP_LINKS_LOAD_LEVEL || linkLevel == UP_DOWN_LINKS_LOAD_LEVEL || linkLevel == ALGORITHMS_OPTIMIZATION_LOAD_LEVEL) { if(record.isDefined(CalendarTemplateElementTableSync::COL_CALENDAR_ID)) { CalendarTemplate* value(NULL); RegistryKeyType id( record.getDefault<RegistryKeyType>( CalendarTemplateElementTableSync::COL_CALENDAR_ID, 0 ) ); if(id > 0) try { value = CalendarTemplateTableSync::GetEditable(id, env).get(); } catch (ObjectNotFoundException<CalendarTemplate> e) { Log::GetInstance().warn("Data corrupted in " + CalendarTemplateElementTableSync::TABLE.NAME + "/" + CalendarTemplateElementTableSync::COL_CALENDAR_ID, e); } if(value != getCalendar()) { result = true; setCalendar(value); } } } return result; }
bool PE::_parse_imports() { if (!_ioh || _file_handle == nullptr) { // Image Optional Header wasn't parsed successfully. return false; } if (!_reach_directory(IMAGE_DIRECTORY_ENTRY_IMPORT)) { // No imports return true; } while (true) // We stop at the first NULL IMAGE_IMPORT_DESCRIPTOR. { pimage_import_descriptor iid(new image_import_descriptor); memset(iid.get(), 0, 5*sizeof(boost::uint32_t)); // Don't overwrite the last member (a string) if (20 != fread(iid.get(), 1, 20, _file_handle.get())) { PRINT_ERROR << "Could not read the IMAGE_IMPORT_DESCRIPTOR." << std::endl; return true; // Don't give up on the rest of the parsing. } // Exit condition if (iid->OriginalFirstThunk == 0 && iid->FirstThunk == 0) { break; } // Non-standard parsing. The Name RVA is translated to an actual string here. auto offset = _rva_to_offset(iid->Name); if (!offset) { // Try to use the RVA as a direct address if the imports are outside of a section. offset = iid->Name; } std::string library_name; if (!utils::read_string_at_offset(_file_handle.get(), offset, library_name)) { // It seems that the Windows loader doesn't give up if such a thing happens. if (_imports.size() > 0) { PRINT_WARNING << "Could not read an import's name." << std::endl; break; // Try to continue the parsing with the available imports. } PRINT_ERROR << "Could not read an import's name." << std::endl; return true; } pImportedLibrary library = pImportedLibrary(new ImportedLibrary(library_name, iid)); _imports.push_back(library); } // Parse the IMPORT_LOOKUP_TABLE for each imported library for (auto it = _imports.begin() ; it != _imports.end() ; ++it) { int ilt_offset; auto descriptor = (*it)->get_image_import_descriptor(); if (descriptor == nullptr) { // Should never happen, standard (as opposed to delay-loaded) imports all have image import descriptors. PRINT_WARNING << "Tried to parse imported functions, but no image import descriptor was given!" << DEBUG_INFO_INSIDEPE << std::endl; continue; } if (descriptor->OriginalFirstThunk != 0) { ilt_offset = _rva_to_offset(descriptor->OriginalFirstThunk); } else { // Some packed executables use FirstThunk and set OriginalFirstThunk to 0. ilt_offset = _rva_to_offset(descriptor->FirstThunk); } if (!_parse_import_lookup_table(ilt_offset, *it)) { // Non fatal. Stop trying to parse imports, but the ones already read will still be available. if ((*it)->get_name() != nullptr) { PRINT_WARNING << "An error occurred while trying to read functions imported by " << *(*it)->get_name() << "." << DEBUG_INFO_INSIDEPE << std::endl; } return true; } } return true; }
bool PE::_parse_imports(FILE* f) { if (!_ioh) { // Image Optional Header wasn't parsed successfully. return false; } if (!_reach_directory(f, IMAGE_DIRECTORY_ENTRY_IMPORT)) { // No imports return true; } while (true) // We stop at the first NULL IMAGE_IMPORT_DESCRIPTOR. { pimage_import_descriptor iid(new image_import_descriptor); memset(iid.get(), 0, 5*sizeof(boost::uint32_t)); // Don't overwrite the last member (a string) if (20 != fread(iid.get(), 1, 20, f)) { PRINT_ERROR << "Could not read the IMAGE_IMPORT_DESCRIPTOR." << std::endl; return true; // Don't give up on the rest of the parsing. } // Exit condition if (iid->OriginalFirstThunk == 0 && iid->FirstThunk == 0) { break; } // Non-standard parsing. The Name RVA is translated to an actual string here. auto offset = _rva_to_offset(iid->Name); if (!offset) { // Try to use the RVA as a direct address if the imports are outside of a section. offset = iid->Name; } if (!utils::read_string_at_offset(f, offset, iid->NameStr)) { // It seems that the Windows loader doesn't give up if such a thing happens. if (_imports.size() > 0) { PRINT_WARNING << "Could not read an import's name." << std::endl; break; // Try to continue the parsing with the available imports. } PRINT_ERROR << "Could not read an import's name." << std::endl; return true; } pimage_library_descriptor library = boost::make_shared<image_library_descriptor>(iid, std::vector<pimport_lookup_table>()); _imports.push_back(library); } // Parse the IMPORT_LOOKUP_TABLE for each imported library for (auto it = _imports.begin() ; it != _imports.end() ; ++it) { int ilt_offset; if ((*it)->first->OriginalFirstThunk != 0) { ilt_offset = _rva_to_offset((*it)->first->OriginalFirstThunk); } else { // Some packed executables use FirstThunk and set OriginalFirstThunk to 0. ilt_offset = _rva_to_offset((*it)->first->FirstThunk); } if (!ilt_offset || fseek(f, ilt_offset, SEEK_SET)) { PRINT_ERROR << "Could not reach an IMPORT_LOOKUP_TABLE." << std::endl; return true; } 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 = (_ioh->Magic == nt::IMAGE_OPTIONAL_HEADER_MAGIC.at("PE32+") ? 8 : 4); if (size_to_read != fread(&(import->AddressOfData), 1, size_to_read, f)) { PRINT_ERROR << "Could not read the IMPORT_LOOKUP_TABLE." << std::endl; return true; } // Exit condition if (import->AddressOfData == 0) { break; } // 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 true; } unsigned int saved_offset = ftell(f); if (saved_offset == -1 || fseek(f, table_offset, SEEK_SET) || 2 != fread(&(import->Hint), 1, 2, f)) { PRINT_ERROR << "Could not read a HINT/NAME hint." << std::endl; return true; } import->Name = utils::read_ascii_string(f); //TODO: Demangle the import name // Go back to the import lookup table. if (fseek(f, saved_offset, SEEK_SET)) { return true; } } (*it)->second.push_back(import); } } return true; }