void PdbEngine::continueInferior() { resetLocation(); notifyInferiorRunRequested(); notifyInferiorRunOk(); // Callback will be triggered e.g. when breakpoint is hit. postCommand("continue", CB(handleUpdateAll)); }
void GdbCoreEngine::setupInferior() { CHECK_STATE(InferiorSetupRequested); // Do that first, otherwise no symbols are loaded. QFileInfo fi(m_executable); QByteArray path = fi.absoluteFilePath().toLocal8Bit(); postCommand("-file-exec-and-symbols \"" + path + '"', NoFlags, CB(handleFileExecAndSymbols)); }
ops_parse_cb_return_t callback_cmd_get_secret_key(const ops_parser_content_t *content_,ops_parse_cb_info_t *cbinfo) { ops_parser_content_union_t* content=(ops_parser_content_union_t *)&content_->content; const ops_secret_key_t *secret; ops_parser_content_t pc; OPS_USED(cbinfo); // ops_print_packet(content_); switch(content_->tag) { case OPS_PARSER_CMD_GET_SECRET_KEY: cbinfo->cryptinfo.keydata=ops_keyring_find_key_by_id(cbinfo->cryptinfo.keyring,content->get_secret_key.pk_session_key->key_id); if (!cbinfo->cryptinfo.keydata || !ops_is_key_secret(cbinfo->cryptinfo.keydata)) return 0; /* now get the key from the data */ secret=ops_get_secret_key_from_data(cbinfo->cryptinfo.keydata); int tag_to_use = OPS_PARSER_CMD_GET_SK_PASSPHRASE ; int nbtries = 0 ; while( (!secret) && nbtries++ < 3) { if (!cbinfo->cryptinfo.passphrase) { memset(&pc,'\0',sizeof pc); pc.content.secret_key_passphrase.passphrase=&cbinfo->cryptinfo.passphrase; CB(cbinfo,tag_to_use,&pc); if (!cbinfo->cryptinfo.passphrase) { fprintf(stderr,"can't get passphrase\n"); assert(0); } } /* then it must be encrypted */ secret=ops_decrypt_secret_key_from_data(cbinfo->cryptinfo.keydata,cbinfo->cryptinfo.passphrase); free(cbinfo->cryptinfo.passphrase) ; cbinfo->cryptinfo.passphrase = NULL ; tag_to_use = OPS_PARSER_CMD_GET_SK_PASSPHRASE_PREV_WAS_BAD ; } if(!secret) return 0 ; *content->get_secret_key.secret_key=secret; break; default: // return callback_general(content_,cbinfo); break; } return OPS_RELEASE_MEMORY; }
void GdbCoreEngine::setupInferior() { QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state()); // Do that first, otherwise no symbols are loaded. QFileInfo fi(m_executable); QByteArray path = fi.absoluteFilePath().toLocal8Bit(); postCommand("-file-exec-and-symbols \"" + path + '"', CB(handleFileExecAndSymbols)); }
void PlainGdbAdapter::startInferior() { QTC_ASSERT(state() == InferiorStarting, qDebug() << state()); if (!startParameters().processArgs.isEmpty()) m_engine->postCommand(_("-exec-arguments ") + startParameters().processArgs.join(_(" "))); QFileInfo fi(startParameters().executable); m_engine->postCommand(_("-file-exec-and-symbols \"%1\"").arg(fi.absoluteFilePath()), CB(handleFileExecAndSymbols)); }
void GdbPlainEngine::setupInferior() { QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state()); if (!startParameters().processArgs.isEmpty()) { QString args = startParameters().processArgs; postCommand("-exec-arguments " + toLocalEncoding(args)); } postCommand("-file-exec-and-symbols \"" + execFilePath() + '"', CB(handleFileExecAndSymbols)); }
int prev_key(ENTRY *pe, IX_DESC *pix) { RECPOS address; pci = pix; retrieve_block(pci->level, CB(pci->level)); prev_entry(CO(pci->level)); if (CO(pci->level) == -1) { address = block_ptr->p0; } else { address = ENT_ADR(block_ptr, CO(pci->level))->idxptr; } if (address != NULLREC) { do { retrieve_block(++(pci->level), address); address = ENT_ADR(block_ptr, last_entry())->idxptr; } while (address != NULLREC); } if (CO(pci->level) == -1) { do { if(pci->level == 0) { first_key(pci); return (EOIX); } --(pci->level); } while (CO(pci->level) == -1); retrieve_block(pci->level, CB(pci->level)); } copy_entry(pe, ENT_ADR(block_ptr, CO(pci->level))); return ( IX_OK ); }
void GdbPlainEngine::setupInferior() { QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state()); setEnvironmentVariables(); if (!runParameters().inferior.commandLineArguments.isEmpty()) { QString args = runParameters().inferior.commandLineArguments; runCommand({"-exec-arguments " + toLocalEncoding(args), NoFlags}); } runCommand({"-file-exec-and-symbols \"" + execFilePath() + '"', NoFlags, CB(handleFileExecAndSymbols)}); }
void CoreGdbAdapter::setupInferior() { QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state()); // Do that first, otherwise no symbols are loaded. QFileInfo fi(m_executable); const QByteArray sysroot = startParameters().sysroot.toLocal8Bit(); QByteArray path = fi.absoluteFilePath().toLocal8Bit(); if (!sysroot.isEmpty()) m_engine->postCommand("set sysroot " + sysroot); m_engine->postCommand("-file-exec-and-symbols \"" + path + '"', CB(handleFileExecAndSymbols)); }
void RemoteGdbServerAdapter::callTargetRemote() { //m_breakHandler->clearBreakMarkers(); // "target remote" does three things: // (1) connects to the gdb server // (2) starts the remote application // (3) stops the remote application (early, e.g. in the dynamic linker) QString channel = startParameters().remoteChannel; m_engine->postCommand("target remote " + channel.toLatin1(), CB(handleTargetRemote)); }
static void flush(dearmour_arg_t *arg,ops_parse_cb_info_t *cbinfo) { ops_parser_content_t content; if(arg->num_unarmoured == 0) return; content.content.unarmoured_text.data=arg->unarmoured; content.content.unarmoured_text.length=arg->num_unarmoured; CB(cbinfo,OPS_PTAG_CT_UNARMOURED_TEXT,&content); arg->num_unarmoured=0; }
static void retrieve_block(int j, RECPOS r) { if (j == 0) { block_ptr = &(pci->root); } else { get_cache(r); } CB(j) = block_ptr->brec; }
GUI::Widget* ZScriptMainDialog::createDialog(const GUI::WidgetFactory& f) { GUI::Window* win= f.window("Compile ZScript", f.column(GUI::Contents( sizeText=f.text(""), f.buttonRow(GUI::Contents( f.button("&Edit", CB(onEdit)), f.button("&Compile", CB(onCompile)) )), f.buttonRow(GUI::Contents( f.button("&Import", CB(onImport)), f.button("E&xport", CB(onExport)) )), f.button("C&lose", CB(shutDown)) )) ); setSizeText(); return win; }
/* get next, previous entries */ int next_key(ENTRY *pe, IX_DESC *pix) { RECPOS address; if(block_ptr->bend == 0) { return IX_FAIL; } pci = pix; retrieve_block(pci->level, CB(pci->level)); address = ENT_ADR(block_ptr, CO(pci->level))->idxptr; while (address != NULLREC) { retrieve_block(++(pci->level), address); CO(pci->level) = -1; address = block_ptr->p0; } next_entry(CO(pci->level)); if (CO(pci->level) == block_ptr->bend) { do { if(pci->level == 0) { last_key(pci); return (EOIX); } --(pci->level); retrieve_block(pci->level, CB(pci->level)); next_entry(CO(pci->level)); } while (CO(pci->level) == block_ptr->bend); } copy_entry(pe, ENT_ADR(block_ptr, CO(pci->level))); return ( IX_OK ); }
void Fuzzer::ExecuteCallback(const uint8_t *Data, size_t Size) { // We copy the contents of Unit into a separate heap buffer // so that we reliably find buffer overflows in it. std::unique_ptr<uint8_t[]> DataCopy(new uint8_t[Size]); memcpy(DataCopy.get(), Data, Size); AssignTaintLabels(DataCopy.get(), Size); CurrentUnitData = DataCopy.get(); CurrentUnitSize = Size; int Res = CB(DataCopy.get(), Size); (void)Res; assert(Res == 0); CurrentUnitData = nullptr; CurrentUnitSize = 0; }
void TermGdbAdapter::setupInferior() { QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state()); const qint64 attachedPID = m_stubProc.applicationPID(); #ifdef Q_OS_WIN const qint64 attachedMainThreadID = m_stubProc.applicationMainThreadID(); showMessage(QString::fromLatin1("Attaching to %1 (%2)").arg(attachedPID).arg(attachedMainThreadID), LogMisc); #else showMessage(QString::fromLatin1("Attaching to %1").arg(attachedPID), LogMisc); #endif m_engine->notifyInferiorPid(attachedPID); m_engine->postCommand("attach " + QByteArray::number(attachedPID), CB(handleStubAttached)); }
void GdbRemoteServerEngine::callTargetRemote() { QByteArray rawChannel = startParameters().remoteChannel.toLatin1(); QByteArray channel = rawChannel; // Don't touch channels with explicitly set protocols. if (!channel.startsWith("tcp:") && !channel.startsWith("udp:") && !channel.startsWith("file:") && channel.contains(':')) { // "Fix" the IPv6 case with host names without '['...']' if (!channel.startsWith('[') && channel.count(':') >= 2) { channel.insert(0, '['); channel.insert(channel.lastIndexOf(':'), ']'); } channel = "tcp:" + channel; } if (m_isQnxGdb) postCommand("target qnx " + channel, CB(handleTargetQnx)); else if (m_isMulti) postCommand("target extended-remote " + m_serverChannel, CB(handleTargetExtendedRemote)); else postCommand("target remote " + channel, CB(handleTargetRemote), 10); }
void RemoteGdbAdapter::startInferior() { QTC_ASSERT(state() == InferiorStarting, qDebug() << state()); m_engine->postCommand("set architecture " + startParameters().remoteArchitecture.toLatin1()); m_engine->postCommand("set sysroot " + startParameters().sysRoot.toLocal8Bit()); m_engine->postCommand("set solib-search-path " + QFileInfo(startParameters().dumperLibrary).path().toLocal8Bit()); if (!startParameters().processArgs.isEmpty()) { QString args = startParameters().processArgs.join(_(" ")); m_engine->postCommand("-exec-arguments " + args.toLocal8Bit()); } m_engine->postCommand("set target-async on", CB(handleSetTargetAsync)); QString x = startParameters().executable; QFileInfo fi(startParameters().executable); QString fileName = fi.absoluteFilePath(); m_engine->postCommand("-file-exec-and-symbols \"" + fileName.toLocal8Bit() + '"', CB(handleFileExecAndSymbols)); }
GUI::Widget* CheatEditor::createDialog(const GUI::WidgetFactory& f) { GUI::Window* win=f.window("Cheat codes", f.column(GUI::Contents( enabledCB=f.checkbox("Cheats &enabled"), f.row(GUI::Contents(f.text("Level 1"), code1=f.textField(40))), f.row(GUI::Contents(f.text("Level 2"), code2=f.textField(40))), f.row(GUI::Contents(f.text("Level 3"), code3=f.textField(40))), f.row(GUI::Contents(f.text("Level 4"), code4=f.textField(40))), f.buttonRow(GUI::Contents( f.button("O&K", CB(onOK)), f.button("&Cancel", CB(shutDown)) )) )) ); enabledCB->setValue((zcheats.flags&1)!=0); code1->setText(zcheats.codes[0]); code2->setText(zcheats.codes[1]); code3->setText(zcheats.codes[2]); code4->setText(zcheats.codes[3]); return win; }
void PdbEngine::insertBreakpoint(BreakpointModelId id) { BreakHandler *handler = breakHandler(); QTC_CHECK(handler->state(id) == BreakpointInsertRequested); handler->notifyBreakpointInsertProceeding(id); QByteArray loc; if (handler->type(id) == BreakpointByFunction) loc = handler->functionName(id).toLatin1(); else loc = handler->fileName(id).toLocal8Bit() + ':' + QByteArray::number(handler->lineNumber(id)); postCommand("break " + loc, CB(handleBreakInsert), QVariant(id)); }
/* position at start/end of index */ int first_key(IX_DESC *pix) { pci = pix; block_ptr = &(pci->root); CB(0) = 0L; CO(0) = -1; pci->level = 0; while(block_ptr->p0 != NULLREC) { retrieve_block(++(pci->level), block_ptr->p0); CO(pci->level) = -1; } return (IX_OK); }
void RemoteGdbServerAdapter::interruptInferior() { QTC_ASSERT(state() == InferiorStopRequested, qDebug() << state()); if (debuggerCore()->boolSetting(TargetAsync)) { m_engine->postCommand("-exec-interrupt", GdbEngine::Immediate, CB(handleInterruptInferior)); } else { bool ok = m_gdbProc.interrupt(); if (!ok) { // FIXME: Extra state needed? m_engine->showMessage(_("NOTE: INFERIOR STOP NOT POSSIBLE")); m_engine->showStatusMessage(tr("Interrupting not possible")); m_engine->notifyInferiorRunOk(); } } }
void CoreGdbAdapter::setupInferior() { QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state()); // Do that first, otherwise no symbols are loaded. QFileInfo fi(m_executable); const QByteArray sysroot = startParameters().sysroot.toLocal8Bit(); QByteArray path = fi.absoluteFilePath().toLocal8Bit(); if (!sysroot.isEmpty()) { m_engine->postCommand("set sysroot " + sysroot); // sysroot is not enough to correctly locate the sources, so explicitly // relocate the most likely place for the debug source m_engine->postCommand("set substitute-path /usr/src " + sysroot + "/usr/src"); } m_engine->postCommand("-file-exec-and-symbols \"" + path + '"', CB(handleFileExecAndSymbols)); }
void GdbCoreEngine::handleTargetCore(const DebuggerResponse &response) { CHECK_STATE(EngineRunRequested); notifyEngineRunOkAndInferiorUnrunnable(); if (response.resultClass == ResultDone) { showMessage(tr("Attached to core."), StatusBar); // Due to the auto-solib-add off setting, we don't have any // symbols yet. Load them in order of importance. reloadStack(); reloadModulesInternal(); postCommand("p 5", NoFlags, CB(handleRoundTrip)); return; } showStatusMessage(tr("Attach to core \"%1\" failed:").arg(runParameters().coreFile) + QLatin1Char('\n') + QString::fromLocal8Bit(response.data["msg"].data())); notifyEngineIll(); }
void Fuzzer::ExecuteCallback(const uint8_t *Data, size_t Size) { UnitStartTime = system_clock::now(); // We copy the contents of Unit into a separate heap buffer // so that we reliably find buffer overflows in it. std::unique_ptr<uint8_t[]> DataCopy(new uint8_t[Size]); memcpy(DataCopy.get(), Data, Size); AssignTaintLabels(DataCopy.get(), Size); CurrentUnitData = DataCopy.get(); CurrentUnitSize = Size; AllocTracer.Start(); int Res = CB(DataCopy.get(), Size); (void)Res; HasMoreMallocsThanFrees = AllocTracer.Stop(); CurrentUnitSize = 0; CurrentUnitData = nullptr; assert(Res == 0); }
PUBLIC OSErr HOpenRF (INTEGER vref, LONGINT dirid, Str255 name, SignedByte perm, INTEGER *refp) { HParamBlockRec hpb; OSErr retval; hpb.fileParam.ioNamePtr = RM (name); hpb.fileParam.ioVRefNum = CW (vref); hpb.ioParam.ioPermssn = CB (perm); hpb.ioParam.ioMisc = CLC (0); hpb.fileParam.ioDirID = CL (dirid); retval = PBHOpenRF (&hpb, FALSE); if (retval == noErr) *refp = CW (hpb.ioParam.ioRefNum); return retval; }
void testArithmetic(std::string const & filename) { ::libmaus::autoarray::AutoArray<uint8_t> data = ::libmaus::util::GetFileSize::readFile(filename); unsigned int const alph = 8; for ( uint64_t i = 0; i < data.size(); ++i ) data[i] &= (alph-1); ::libmaus::timing::RealTimeClock rtc; rtc.start(); typedef ::libmaus::bitio::BitWriterVector8 bw_type; std::vector < uint8_t > VV; std::back_insert_iterator< std::vector < uint8_t > > it(VV); bw_type CB(it); unsigned int const loops = 3; for ( uint64_t z = 0; z < loops; ++z ) encodeFileArithmetic(data,alph,CB); typedef ::libmaus::bitio::IteratorBitInputStream< std::vector<uint8_t>::const_iterator, true > br_type; br_type CR(VV.begin(),VV.end()); for ( uint64_t z = 0; z < loops; ++z ) { rtc.start(); ::libmaus::arithmetic::ArithmeticDecoder < br_type > AD (CR); model_type MD(alph); ::libmaus::autoarray::AutoArray<uint8_t> ddata(data.size(),false); for ( uint64_t i = 0; i < data.size(); ++i ) ddata[i] = AD.decodeUpdate(MD); AD.flush(true /* read end marker */); std::cerr << "Decoded in " << rtc.getElapsedSeconds() << " s, " << 1./(rtc.getElapsedSeconds()/data.size()); bool ok = true; for ( uint64_t i = 0; i < data.size(); ++i ) ok = ok && (data[i] == ddata[i]); std::cout << " " << (ok ? "ok" : "failed") << std::endl; } std::cerr << static_cast<double>(loops*data.size()) / VV.size() << std::endl; }
void PlainGdbAdapter::handleFileExecAndSymbols(const GdbResponse &response) { QTC_ASSERT(state() == InferiorStarting, qDebug() << state()); if (response.resultClass == GdbResultDone) { #ifdef Q_OS_LINUX // Old gdbs do not announce the PID for programs without pthreads. // Note that successfully preloading the debugging helpers will // automatically load pthreads, so this will be unnecessary. if (m_engine->m_gdbVersion < 70000) m_engine->postCommand(_("info target"), CB(handleInfoTarget)); #endif emit inferiorPrepared(); } else { QString msg = tr("Starting executable failed:\n") + QString::fromLocal8Bit(response.data.findChild("msg").data()); emit inferiorStartFailed(msg); } }
int last_key(IX_DESC *pix) { long ads; pci = pix; block_ptr = &(pci->root); CB(0) = 0L; pci->level = 0; if(last_entry() >= 0) { while ((ads = ENT_ADR(block_ptr,last_entry())->idxptr) != NULLREC) { retrieve_block(++(pci->level), ads); } } CO(pci->level) = block_ptr->bend; return ( IX_OK ); }
void CoreGdbAdapter::startAdapter() { QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state()); showMessage(_("TRYING TO START ADAPTER")); QStringList args; args.append(_("-ex")); args.append(_("set auto-solib-add off")); if (!m_engine->startGdb(args, QString())) return; //if (m_executable.isEmpty()) { // showMessageBox(QMessageBox::Warning, // tr("Error Loading Symbols"), // tr("No executable to load symbols from specified.")); //} #ifdef Q_OS_LINUX const bool canUseExeFromCore = true; #else const bool canUseExeFromCore = false; #endif if (!m_executable.isEmpty()) { m_engine->notifyEngineSetupOk(); } else if (canUseExeFromCore) { // Extra round trip to get executable name from core file. // This is sometimes not the full name, so it can't be used // as the generic solution. // Quoting core name below fails in gdb 6.8-debian. m_engine->postCommand("target core " + m_coreName, CB(handleTemporaryTargetCore)); } else { QString msg = tr("The name of the binary file cannot be extracted " "from this core file."); msg += _(" "); msg += tr("Try to specify the binary using the " "<i>Debug->Start Debugging->Attach to Core</i> dialog."); showMessageBox(QMessageBox::Warning, tr("Loading core file failed"), msg); m_engine->notifyEngineSetupFailed(); } }