void replaceFunc (AstCFunc* oldfuncp, AstCFunc* newfuncp) {
if (oldfuncp==newfuncp) return;
if (newfuncp) {
UINFO(4, " Replace "<<oldfuncp<<" -WITH-> "<<newfuncp<<endl);
} else UINFO(4, " Remove "<<oldfuncp<<endl);
pair <CallMmap::iterator,CallMmap::iterator> eqrange = m_callMmap.equal_range(oldfuncp);
for (CallMmap::iterator nextit = eqrange.first; nextit != eqrange.second;) {
CallMmap::iterator eqit = nextit++;
AstCCall* callp = eqit->second;
if (!callp->user3()) { // !already done
UINFO(4, " Called "<<callp<<endl);
if (callp->funcp() != oldfuncp) callp->v3fatalSrc("Call list broken, points to call w/different func");
if (newfuncp) {
AstCCall* newp = new AstCCall(callp, newfuncp);
// Special new AstCCall form above transfers children of callp to newfuncp
callp->replaceWith(newp);
addCall(newp); // Fix the table
} else { // Just deleting empty function
callp->unlinkFrBack();
}
callp->user3(true); // Dead now
pushDeletep(callp); VL_DANGLING(callp);
m_callMmap.erase(eqit); // Fix the table
}
}
}
int Client::getRandomNumberAsync()
{
qlonglong id = invokeOnPeer("getRandomNumberSlot");
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(NoronRemoteCallBase::EventLoop);
addCall(id, call);
}
}
int Client::getRandomNumberWithTimeoutAsync(int timeout)
{
qlonglong id = invokeOnPeer("getRandomNumberWithTimeoutSlot", timeout);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(NoronRemoteCallBase::EventLoop);
addCall(id, call);
}
}
int Client::getRandomNumber(QJSValue callbackFunction)
{
qlonglong id = invokeOnPeer("getRandomNumberSlot");
if(id){
NoronRemoteCall<int> *call = new NoronRemoteCall<int>(callbackFunction);
addCall(id, call);
}
}
int Client::getRandomNumber(const QObject *obj, char *callbackSlot)
{
qlonglong id = invokeOnPeer("getRandomNumberSlot");
if(id){
NoronRemoteCall<int> *call = new NoronRemoteCall<int>(const_cast<QObject *>(obj), callbackSlot);
addCall(id, call);
}
}
int Client::getRandomNumberWithTimeout(int timeout, QJSValue callbackFunction)
{
qlonglong id = invokeOnPeer("getRandomNumberWithTimeoutSlot", timeout);
if(id){
NoronRemoteCall<int> *call = new NoronRemoteCall<int>(callbackFunction);
addCall(id, call);
}
}
int Client::getRandomNumberWithTimeout(int timeout, const QObject *obj, const QMetaMethod *callbackMethod)
{
qlonglong id = invokeOnPeer("getRandomNumberWithTimeoutSlot", timeout);
if(id){
NoronRemoteCall<int> *call = new NoronRemoteCall<int>(const_cast<QObject *>(obj), const_cast<QMetaMethod *>(callbackMethod));
addCall(id, call);
}
}
void Server::imageSent(QString username, QPixmap image, const QObject *obj, char *callbackSlot)
{
qlonglong id = invokeOnPeer("imageSentSlot", username,image);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(const_cast<QObject *>(obj), callbackSlot);
addCall(id, call);
}
}
void Server::imageSent(QString username, QPixmap image, std::function<void(void)> callbackFunction)
{
qlonglong id = invokeOnPeer("imageSentSlot", username,image);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(callbackFunction);
addCall(id, call);
}
}
void Server::broadcastMessage(QString message, std::function<void(void)> callbackFunction)
{
qlonglong id = invokeOnPeer("broadcastMessageSlot", message);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(callbackFunction);
addCall(id, call);
}
}
void Server::userLeaved(QString username, QJSValue callbackFunction)
{
qlonglong id = invokeOnPeer("userLeavedSlot", username);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(callbackFunction);
addCall(id, call);
}
}
void Server::userLeavedAsync(QString username)
{
qlonglong id = invokeOnPeer("userLeavedSlot", username);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(NoronRemoteCallBase::EventLoop);
addCall(id, call);
}
}
void Server::userLeaved(QString username, const QObject *obj, char *callbackSlot)
{
qlonglong id = invokeOnPeer("userLeavedSlot", username);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(const_cast<QObject *>(obj), callbackSlot);
addCall(id, call);
}
}
void Server::broadcastMessageAsync(QString message)
{
qlonglong id = invokeOnPeer("broadcastMessageSlot", message);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(NoronRemoteCallBase::EventLoop);
addCall(id, call);
}
}
void Server::userJoined(QString username, std::function<void(void)> callbackFunction)
{
qlonglong id = invokeOnPeer("userJoinedSlot", username);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(callbackFunction);
addCall(id, call);
}
}
void Server::broadcastMessage(QString message, const QObject *obj, char *callbackSlot)
{
qlonglong id = invokeOnPeer("broadcastMessageSlot", message);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(const_cast<QObject *>(obj), callbackSlot);
addCall(id, call);
}
}
void Server::imageSentAsync(QString username, QPixmap image)
{
qlonglong id = invokeOnPeer("imageSentSlot", username,image);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(NoronRemoteCallBase::EventLoop);
addCall(id, call);
}
}
void Server::broadcastMessage(QString message, const QObject *obj, const QMetaMethod *callbackMethod)
{
qlonglong id = invokeOnPeer("broadcastMessageSlot", message);
if(id){
QObject *target = const_cast<QObject *>(obj);
NoronRemoteCallBase *call = new NoronRemoteCallBase(const_cast<QObject *>(obj), const_cast<QMetaMethod *>(callbackMethod));
addCall(id, call);
}
}
void Server::userLeaved(QString username, const QObject *obj, const QMetaMethod *callbackMethod)
{
qlonglong id = invokeOnPeer("userLeavedSlot", username);
if(id){
QObject *target = const_cast<QObject *>(obj);
NoronRemoteCallBase *call = new NoronRemoteCallBase(const_cast<QObject *>(obj), const_cast<QMetaMethod *>(callbackMethod));
addCall(id, call);
}
}
void Server::userLeaved(QString username)
{
qlonglong id = invokeOnPeer("userLeavedSlot", username);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(NoronRemoteCallBase::EventLoop);
addCall(id, call);
call->eventLoop->exec();
removeCall(id);
delete call;
}
}
void Server::broadcastMessage(QString message)
{
qlonglong id = invokeOnPeer("broadcastMessageSlot", message);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(NoronRemoteCallBase::EventLoop);
addCall(id, call);
call->eventLoop->exec();
removeCall(id);
delete call;
}
}
void Server::imageSent(QString username, QPixmap image)
{
qlonglong id = invokeOnPeer("imageSentSlot", username,image);
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(NoronRemoteCallBase::EventLoop);
addCall(id, call);
call->eventLoop->exec();
removeCall(id);
delete call;
}
}
void IAXVoIPLink::iaxHandlePrecallEvent(iax_event* event)
{
IAXCall *call;
std::string id;
int format;
switch (event->etype) {
case IAX_EVENT_CONNECT:
id = Manager::instance().getNewCallID();
call = new IAXCall(id, Call::INCOMING);
call->session = event->session;
call->setConnectionState(Call::PROGRESSING);
if (event->ies.calling_number)
call->setPeerNumber(event->ies.calling_number);
if (event->ies.calling_name)
call->setDisplayName(std::string(event->ies.calling_name));
// if peerNumber exist append it to the name string
call->initRecFilename(std::string(event->ies.calling_number));
Manager::instance().incomingCall(*call, accountID_);
format = call->getFirstMatchingFormat(event->ies.format, accountID_);
if (!format)
format = call->getFirstMatchingFormat(event->ies.capability, accountID_);
iax_accept(event->session, format);
iax_ring_announce(event->session);
addCall(call);
call->format = format;
break;
case IAX_EVENT_HANGUP:
id = iaxFindCallBySession(event->session)->getCallId();
Manager::instance().peerHungupCall(id);
removeCall(id);
break;
case IAX_EVENT_TIMEOUT: // timeout for an unknown session
case IAX_IE_MSGCOUNT:
case IAX_EVENT_REGACK:
case IAX_EVENT_REGREJ:
case IAX_EVENT_REGREQ:
// Received when someone wants to register to us!?!
// Asterisk receives and answers to that, not us, we're a phone.
default:
break;
}
}
Call*
IAXVoIPLink::newOutgoingCall(const std::string& id, const std::string& toUrl)
{
IAXCall* call = new IAXCall(id, Call::OUTGOING);
call->setPeerNumber(toUrl);
call->initRecFilename(toUrl);
iaxOutgoingInvite(call);
call->setConnectionState(Call::PROGRESSING);
call->setState(Call::ACTIVE);
addCall(call);
return call;
}
int Client::getRandomNumber()
{
qlonglong id = invokeOnPeer("getRandomNumberSlot");
if(id){
NoronRemoteCallBase *call = new NoronRemoteCallBase(NoronRemoteCallBase::EventLoop);
addCall(id, call);
call->eventLoop->exec();
int ret = call->returnData.value<int>();
removeCall(id);
delete call;
return ret;
}
}
/**
*
* @brief creates transitions for 'dup' mirroring 'orig' outgoing transitions
*
* @param - orig: the state that is being duplicated
* @param - dup: the state that is duplicating 'orig'
*
*/
void TransitionStorage::dupTransOutgoing( State orig, State dup )
{
// Duplicate outgoing internal transitions.
const Info::Internals & from = T_info.fromTrans(orig);
for( Info::InternalIterator it = from.begin(); it != from.end(); it++ )
{
Internal iTrans(dup,getInternalSym(*it),getTarget(*it));
addInternal(iTrans);
}
// Duplicate call site call transitions.
const Info::Calls & call = T_info.callTrans(orig);
for( Info::CallIterator it = call.begin(); it != call.end(); it++ )
{
Call cTrans(dup,getCallSym(*it),getEntry(*it));
addCall(cTrans);
}
// Duplicate exit point return transitions.
const Info::Returns & exit = T_info.exitTrans(orig);
for( Info::ReturnIterator it = exit.begin(); it != exit.end(); it++ )
{
Return rTrans(dup,getCallSite(*it),getReturnSym(*it),getReturnSite(*it));
addReturn(rTrans);
}
// Q: Do we want to do these? Seems inconsistent. -Evan
// A: Aditya says 'yes', and thinks we need it. So we definitely don't
// want to change it without looking at uses and compensating.
// Duplicate call predecessor return transitions.
const Info::Returns & pred = T_info.predTrans(orig);
for( Info::ReturnIterator it = pred.begin(); it != pred.end(); it++ )
{
Return rTrans(getExit(*it),dup,getReturnSym(*it),getReturnSite(*it));
addReturn(rTrans);
}
}
/**
* Shows a list of function calls from the current node.
* The list is displayed in a query dialogue. The user can the select which
* calls should be displayed in the graph.
* This slot is connected to the "List Called Functions" popup menu
* action.
*/
void GraphWidget::slotListCalled()
{
GraphNode* pNode;
// Make sure the menu item is a node
pNode = dynamic_cast<GraphNode*>(m_pMenuItem);
if (pNode == NULL)
return;
QueryViewDlg dlg(0, (QWidget*)parent());
// Show the query view dialogue
dlg.query(CscopeFrontend::Called, pNode->getFunc());
if (dlg.exec() != QDialog::Accepted)
return;
// The OK button was clicked, replace current calls with the listed ones
pNode->removeOutEdges();
QueryView::Iterator itr;
CallData data;
data.m_sCaller = pNode->getFunc();
// Add all listed calls
for (itr = dlg.getIterator(); !itr.isEOF(); itr.next()) {
data.m_sCallee = itr.getFunc();
data.m_sFile = itr.getFile();
data.m_sLine = itr.getLine();
data.m_sText = itr.getText();
addCall(data);
}
// Clean-up and redraw the graph
removeDisconnected(pNode);
draw();
}
/**
*
* @brief add all transitions in the given collection of transitions to this
* collection of transitions
*
* @param - addTransitionStorage: the collection of transitions to add to this
* collection of transitions
*
*/
void TransitionStorage::addAllTrans( TransitionStorage addTransSet )
{
//Add call transitions.
for(CallIterator it = addTransSet.beginCall();
it != addTransSet.endCall(); it ++ )
{
addCall(*it);
}
//Add internal transitions.
for(InternalIterator it = addTransSet.beginInternal();
it != addTransSet.endInternal(); it ++ )
{
addInternal(*it);
}
//Add return transitions.
for(ReturnIterator it = addTransSet.beginReturn();
it != addTransSet.endReturn(); it ++ )
{
addReturn(*it);
}
}
/**
* Adds an entry to the tree, as the child of the active item.
* Called by a CscopeFrontend object, when a new entry was received in its
* whole from the Cscope back-end process. The entry contains the data of a
* function calling the function described by the active item.
* @param pToken The first token in the entry
*/
void GraphWidget::slotDataReady(FrontendToken* pToken)
{
CallData data;
QString sFunc;
// Get the file name
data.m_sFile = pToken->getData();
pToken = pToken->getNext();
// Get the function name
sFunc = pToken->getData();
pToken = pToken->getNext();
// Get the line number (do not accept global information on a call tree)
data.m_sLine = pToken->getData();
if (data.m_sLine.toUInt() == 0)
return;
pToken = pToken->getNext();
// Get the line's text
data.m_sText = pToken->getData();
// Determine the caller and the callee
if (m_bCalled) {
data.m_sCaller = m_sQueriedFunc;
data.m_sCallee = sFunc;
}
else {
data.m_sCaller = sFunc;
data.m_sCallee = m_sQueriedFunc;
}
// Add the call to the graph
addCall(data);
}
ut64 analyzeStackBased(RCore *core, Sdb *db, ut64 addr, RList *delayed_commands) {
#define addCall(x) sdb_array_add_num (db, "calls", x, 0);
#define addUcall(x) sdb_array_add_num (db, "ucalls", x, 0);
#define addUjmp(x) sdb_array_add_num (db, "ujmps", x, 0);
#define addCjmp(x) sdb_array_add_num (db, "cjmps", x, 0);
#define addRet(x) sdb_array_add_num (db, "rets", x, 0);
#define bbAddOpcode(x) sdb_array_insert_num (db, sdb_fmt ("bb.%"PFMT64x, addr+cur), -1, x, 0);
ut64 oaddr = addr;
ut64 *value = NULL;
RAnalOp *op;
int cur = 0;
bool block_end = false;
RStack *stack = r_stack_newf (10, free);
addTarget (core, stack, db, addr);
while (!r_stack_is_empty (stack)) {
block_end = false;
value = (ut64*) r_stack_pop (stack);
if (!value) {
eprintf ("Failed to pop next address from stack\n");
break;
}
addr = *value;
free (value);
cur = 0;
while (!block_end) {
op = r_core_anal_op (core, addr + cur, R_ANAL_OP_MASK_BASIC);
if (!op || !op->mnemonic) {
eprintf ("Cannot analyze opcode at %"PFMT64d"\n", addr+cur);
oaddr = UT64_MAX;
break;
}
if (op->mnemonic[0] == '?') {
eprintf ("Cannot analyze opcode at %"PFMT64d"\n", addr+cur);
oaddr = UT64_MAX;
break;
}
bbAddOpcode (addr+cur);
switch (op->type) {
case R_ANAL_OP_TYPE_NOP:
// skip nops
if (cur == 0) {
cur -= op->size;
addr += op->size;
oaddr += op->size;
}
break;
case R_ANAL_OP_TYPE_CALL:
/* A call instruction implies that the destination
* is a new function unless the address is inside
* the same range than the current function */
addCall (op->jump);
r_list_append (delayed_commands, r_str_newf ("axC %"PFMT64d" %"PFMT64d, op->jump, addr + cur));
break;
case R_ANAL_OP_TYPE_UCALL:
case R_ANAL_OP_TYPE_ICALL:
case R_ANAL_OP_TYPE_RCALL:
case R_ANAL_OP_TYPE_IRCALL:
/* unknown calls depend on ESIL or DEBUG tracing
* information to know the destination, we can mark
* those 'calls' for later adding tracepoints in
* there to record all possible destinations */
addUcall (addr+cur);
if (op->ptr != UT64_MAX) {
r_list_append (delayed_commands, r_str_newf ("axC %"PFMT64d" %"PFMT64d, op->ptr, addr + cur));
}
break;
case R_ANAL_OP_TYPE_UJMP:
case R_ANAL_OP_TYPE_RJMP:
case R_ANAL_OP_TYPE_IJMP:
case R_ANAL_OP_TYPE_IRJMP:
/* an unknown jump use to go into computed destinations
* outside the current function, but it may result
* on an antidisasm trick */
addUjmp (addr + cur);
/* An unknown jump breaks the basic blocks */
block_end = true; // XXX more investigation here
break;
case R_ANAL_OP_TYPE_TRAP:
if (cur == 0) {
// skip leading int3
cur -= op->size;
addr += op->size;
oaddr += op->size;
} else {
block_end = true;
}
break;
case R_ANAL_OP_TYPE_RET:
addRet (addr + cur);
bbAdd (db, addr, addr + cur + op->size, UT64_MAX, UT64_MAX);
block_end = true;
break;
case R_ANAL_OP_TYPE_CJMP:
addCjmp (addr+cur);
bbAdd (db, addr, addr + cur + op->size, op->jump, addr + cur + op->size);
addTarget (core, stack, db, op->jump);
addTarget (core, stack, db, addr + cur + op->size);
block_end = true;
r_list_append (delayed_commands, r_str_newf ("axc %"PFMT64d" %"PFMT64d, op->jump, addr + cur));
break;
case R_ANAL_OP_TYPE_JMP:
addUjmp (addr+cur);
bbAdd (db, addr, addr + cur + op->size, op->jump, UT64_MAX);
addTarget (core, stack, db, op->jump);
block_end = true;
r_list_append (delayed_commands, r_str_newf ("axc %"PFMT64d" %"PFMT64d, op->jump, addr + cur));
break;
case R_ANAL_OP_TYPE_UNK:
case R_ANAL_OP_TYPE_ILL:
eprintf ("a2f: Invalid instruction\n");
block_end = true;
break;
default:
if (op->ptr != UT64_MAX) {
r_list_append (delayed_commands, r_str_newf ("axd %"PFMT64d" %"PFMT64d, op->ptr, addr + cur));
}
break;
}
cur += op->size;
r_anal_op_free (op);
op = NULL;
}
}
r_stack_free (stack);
return oaddr;
}