/**
* Set this tap's IP addresses to exactly this set of IPs
*
* New IPs are created. Any IP that overlaps with the network of an IP in
* this list is removed, but other IPs are left intact.
*
* @param ips IP addresses with netmask in port field
*/
inline void setIps(const std::set<InetAddress> &allIps)
{
for(std::set<InetAddress>::iterator i(allIps.begin());i!=allIps.end();++i)
addIP(*i);
std::set<InetAddress> myIps(ips());
#ifdef __APPLE__
bool haveV6LinkLocal = false;
for(std::set<InetAddress>::iterator i(myIps.begin());i!=myIps.end();++i) {
if (i->isLinkLocal()) {
if (i->isV6())
haveV6LinkLocal = true;
} else if (!allIps.count(*i)) {
for(std::set<InetAddress>::const_iterator i2(allIps.begin());i2!=allIps.end();++i2) {
if (i->sameNetworkAs(*i2)) {
removeIP(*i);
break;
}
}
}
}
if (!haveV6LinkLocal)
addIP(InetAddress::makeIpv6LinkLocal(_mac));
#else
for(std::set<InetAddress>::iterator i(myIps.begin());i!=myIps.end();++i) {
if ((!i->isLinkLocal())&&(!allIps.count(*i))) {
for(std::set<InetAddress>::const_iterator i2(allIps.begin());i2!=allIps.end();++i2) {
if (i->sameNetworkAs(*i2)) {
removeIP(*i);
break;
}
}
}
}
#endif
}
int getCurrentStackTrace(size_t skip, StackTrace* trace) {
trace->frameIPs = NULL;
trace->frameCount = 0;
struct Context ctx;
ctx.trace = trace;
ctx.skip = skip;
ctx.capacity = 0;
unw_context_t uctx;
int r = unw_getcontext(&uctx);
int err = checkError("unw_get_context", r);
if (err) return err;
unw_cursor_t cursor;
r = unw_init_local(&cursor, &uctx);
err = checkError("unw_init_local", r);
if (err) return err;
while ((r = unw_step(&cursor)) > 0) {
if ((err = addIP(&ctx, &cursor)) != 0) {
destroyStackTrace(trace);
return err;
}
}
err = checkError("unw_step", r);
if (err) return err;
return 0;
}
/**
* Set this tap's IP addresses to exactly this set of IPs
*
* New IPs are created, ones not in this list are removed.
*
* @param ips IP addresses with netmask in port field
*/
inline void setIps(const std::set<InetAddress> &allIps)
{
for(std::set<InetAddress>::iterator i(allIps.begin());i!=allIps.end();++i)
addIP(*i);
std::set<InetAddress> myIps(ips());
for(std::set<InetAddress>::iterator i(myIps.begin());i!=myIps.end();++i) {
if (!allIps.count(*i))
removeIP(*i);
}
}
/*=========================================================================
* FUNCTION: tVM_Execute
* TYPE: public interface
* OVERVIEW: execute a basic function
* INTERFACE:
* parameters:
* returns:
* the result of the basic function
*=======================================================================*/
int tVM_Execute()
{
int running = 1;
u8 bytecode;
u8 type;
u8 ac_flag;
s32 integer;
s32 stackindex,index;
tVMValue value1,value2,value3;
tVMValue retValue;// = (tVMValue*)mem_alloc(sizeof(tVMValue));
/* initialize the running Stack FP */
setFP(FirstFP);
/* seek to the entry function */
setFI(0);
/* initialize the code reader */
tVM_InitializeCodeReader();
/* execute the byte codes in loop */
while(running)
{
bytecode = ReadCode();
switch(bytecode)
{
case C_NOP:
break;
case C_CONST:
{
ReadVMValue(&value1);
PushVMValue(&value1);
break;
}
case C_LOAD:
{
ac_flag =ReadAccessFlag();
if(ac_flag == ACCESS_FLAG_GLOBAL)
stackindex = ReadIndex();
else
stackindex = ReadIndex() + getFP();
LoadVMValue(stackindex,&value1);
PushVMValue(&value1);
break;
}
case C_STORE:
{
ac_flag =ReadAccessFlag();
if(ac_flag == ACCESS_FLAG_GLOBAL)
stackindex = ReadIndex();
else
stackindex = ReadIndex() + getFP();
PopVMValue(&value1); /* pop the source value */
StoreVMValue(stackindex,&value1);
break;
}
case C_HEAP_LOAD:
{
type = ReadDataType();
PopVMValue(&value2); /* Pop Addr */
PopVMValue(&value1); /* Pop Base */
tVMValue_HeapLoad(value1.value.ptr_val+value2.value.int_val,type,&value3); /* load the heap memory */
PushVMValue(&value3); /* push the loaded value */
break;
}
case C_HEAP_STORE:
{
ptr32 addr;
type = ReadDataType();
PopVMValue(&value3); /* Pop Addr */
PopVMValue(&value2); /* Pop Base */
PopVMValue(&value1); /* Pop Value */
addr = (ptr32)(value2.value.ptr_val + value3.value.int_val);
if(value1.type != type)
{
tVMValue_ConvertType(&value1,type);
}
tVMValue_HeapStore(addr,&value1);
break;
}
case C_FORCE_LOAD:
{
ac_flag =ReadAccessFlag();
if(ac_flag == ACCESS_FLAG_GLOBAL)
stackindex = ReadIndex();
else
stackindex = ReadIndex() + getFP();
type = ReadDataType();
ForceLoadVMValue(stackindex,type,&value1);
PushVMValue(&value1);
break;
}
case C_ALLOC:
{
PopVMValue(&value1);
value2.type = PtrType;
value2.value.ptr_val = (ptr32)mem_alloc(value1.value.int_val);
memset(value2.value.ptr_val,0,value1.value.int_val);
PushVMValue(&value2);
break;
}
case C_ALLOC_ARRAY:
{
s32 i;
s32 dimension;
s32* index_ranges;
dimension = ReadInteger();
if(dimension < 1)
break;
index_ranges = (s32*)mem_alloc(sizeof(s32)*dimension);
for(i=0;i<dimension;i++)
{
PopVMValue(&value1);
index_ranges[dimension-i-1] = value1.value.int_val;
}
value1.type = PtrType;
value1.value.ptr_val = tVMValue_HeapAllocMultiArray(dimension,index_ranges,0);
PushVMValue(&value1);
mem_free(index_ranges);
break;
}
case C_FREE:
{
PopVMValue(&value1);
if(value1.value.ptr_val != NULL)
mem_free(value1.value.ptr_val);
break;
}
case C_FREE_ARRAY:
{
break;
}
case C_PUSH:
{
value1.type = ReadDataType();
value1.value.int_val = 0;
PushVMValue(&value1);
break;
}
case C_POP:
{
s32 i;
integer = ReadInteger();
for(i=0;i<integer;i++)
{
PopVMValue(&value1);
tVMValue_FreeSelf(&value1);
}
break;
}
case C_POP_RESTOP:
{
s32 i;
integer = ReadInteger();
PopVMValue(&value2); /* reserve top value */
for(i=0;i<integer;i++)
{
PopVMValue(&value1);
tVMValue_FreeSelf(&value1);
}
PushVMValue(&value2); /* push back top value */
break;
}
case C_CONVERT:
{
u8 type = (u8)ReadDataType();
PopVMValue(&value1);
tVMValue_ConvertType(&value1,type);
PushVMValue(&value1);
break;
}
case C_ADD:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_Add(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_SUB:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_Sub(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_MUL:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_Mul(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_DIV:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_Div(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_MOD:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_Mod(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_OPP:
{
PopVMValue(&value1);
tVMValue_Opp(&value1,&value2);
PushVMValue(&value2);
tVMValue_FreeSelf(&value1);
break;
}
case C_AND:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_AND(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_OR:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_OR(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_EQ:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_EQ(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_NOT_EQ:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_NOTEQ(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_LT:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_LT(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_LG:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_LG(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_LT_EQ:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_LTEQ(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_LG_EQ:
{
PopVMValue(&value2);
PopVMValue(&value1);
tVMValue_LGEQ(&value1,&value2,&value3);
PushVMValue(&value3);
tVMValue_FreeSelf(&value1);
tVMValue_FreeSelf(&value2);
break;
}
case C_FJP:
{
s32 size = ReadIndex();
PopVMValue(&value1);
if(value1.value.int_val == 0) /* if it is false */
addIP(size);
break;
}
case C_TJP:
{
s32 size = ReadIndex();
PopVMValue(&value1);
if(value1.value.int_val != 0) /* if it is true */
addIP(size);
break;
}
case C_JMP:
{
s32 size = ReadIndex();
addIP(size);
break;
}
case C_CALL:
{
/* read function name */
integer = ReadIndex();
/* push the stack frame */
PushInteger(getIP());
PushInteger(getFI());
PushInteger(getFP());
/* goto the call function code */
tVM_ReleaseCodeReader();
setFI(integer);
tVM_InitializeCodeReader();
/* set new FP,RP */
setFP(getSP());
break;
}
case C_INVOKE:
{
/* read function name */
index = ReadIndex();
/* execute the native function */
tNativeFunction_Invoke(index);
break;
}
case C_RET:
{
u32 param_bytes = ReadIndex();
/* get the result of the function */
retValue.type = NullType;
PopVMValue(&retValue);
/* if this is the start function,then exit the loop */
if(getFP() == FirstFP)
{
running = 0; /* set flag to stop while */
break;
}
/* restore last stack frame and return to last function code */
tVM_ReleaseCodeReader();
PopInteger(integer);
setFP(integer);
PopInteger(integer);
setFI(integer);
tVM_InitializeCodeReader();
PopInteger(integer);
setIP(integer);
/* pop the old parameters */
PopBytes(param_bytes);
/* push back result of last function */
PushVMValue(&retValue);
break;
}
}
}
/* close the code reader */
tVM_ReleaseCodeReader();
return 1;
}
INT32 _omTaskStrategyInfo::fromBSON( const BSONObj &obj )
{
INT32 rc = SDB_OK ;
BSONElement beField ;
BSONObj ipsObj ;
beField = obj.getField( OM_REST_FIELD_RULE_ID ) ;
if ( !beField.isNumber() )
{
PD_LOG( PDERROR, "Field[%s] must be number",
beField.toString( TRUE, TRUE ).c_str() ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
setID( beField.numberLong() ) ;
beField = obj.getField( OM_REST_FIELD_TASK_ID ) ;
if ( !beField.isNumber() )
{
PD_LOG( PDERROR, "Field[%s] must be number",
beField.toString( TRUE, TRUE ).c_str() ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
setTaskID( beField.numberLong() ) ;
beField = obj.getField( OM_REST_FIELD_TASK_NAME ) ;
if ( String != beField.type() )
{
PD_LOG( PDERROR, "Field[%s] must be string",
beField.toString( TRUE, TRUE ).c_str() ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
setTaskName( beField.str() ) ;
beField = obj.getField( OM_REST_FIELD_NICE ) ;
if ( !beField.isNumber() )
{
PD_LOG( PDERROR, "Field[%s] must be number",
beField.toString( TRUE, TRUE ).c_str() ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
setNice( beField.numberInt() ) ;
beField = obj.getField( OM_REST_FIELD_USER_NAME ) ;
if ( String != beField.type() )
{
PD_LOG( PDERROR, "Field[%s] must be string",
beField.toString( TRUE, TRUE ).c_str() ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
setUserName( beField.str() ) ;
beField = obj.getField( OM_REST_FIELD_IPS ) ;
if ( Array != beField.type() )
{
PD_LOG( PDERROR, "Field[%s] must be string array",
beField.toString( TRUE, TRUE ).c_str() ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
else
{
clearIPSet() ;
string tmpStr ;
BSONElement e ;
BSONObjIterator itr( beField.embeddedObject() ) ;
while( itr.more() )
{
e = itr.next() ;
if ( String != beField.type() )
{
PD_LOG( PDERROR, "Field[%s] must be string array",
beField.toString( TRUE, TRUE ).c_str() ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
tmpStr = e.str() ;
if ( !tmpStr.empty() )
{
addIP( tmpStr ) ;
}
}
}
done:
return rc ;
error:
goto done ;
}
// Creates a SDP body from transport address and list of media descriptors
// Use own list if given media list is 0
MimeSdpBody* SDPSession::createSDP(const char* addr, ObjList* mediaList)
{
DDebug(m_enabler,DebugAll,"SDPSession::createSDP('%s',%p) [%p]",addr,mediaList,m_ptr);
if (!mediaList)
mediaList = m_rtpMedia;
// if we got no media descriptors we simply create no SDP
if (!mediaList)
return 0;
if (m_sdpSession)
++m_sdpVersion;
else
m_sdpVersion = m_sdpSession = Time::secNow();
// override the address with the externally advertised if needed
if (addr && m_rtpNatAddr)
addr = m_rtpNatAddr;
if (!m_originAddr)
m_originAddr = addr ? addr : m_host.safe();
// no address means on hold or muted
String origin;
origin << "yate " << m_sdpSession << " " << m_sdpVersion;
origin << " ";
int f = addIP(origin,m_originAddr);
String conn;
addIP(conn,addr,f);
MimeSdpBody* sdp = new MimeSdpBody;
sdp->addLine("v","0");
sdp->addLine("o",origin);
sdp->addLine("s",m_parser->m_sessionName);
sdp->addLine("c",conn);
sdp->addLine("t","0 0");
Lock lock(m_parser);
bool defcodecs = m_parser->m_codecs.getBoolValue("default",true);
for (ObjList* ml = mediaList->skipNull(); ml; ml = ml->skipNext()) {
SDPMedia* m = static_cast<SDPMedia*>(ml->get());
int rfc2833 = 0;
if ((m_rfc2833 >= 0) && m->isAudio()) {
if (!m_rtpForward) {
rfc2833 = m->rfc2833().toInteger(m_rfc2833);
if (rfc2833 < 96 || rfc2833 > 127)
rfc2833 = 101;
}
else if (m->rfc2833().toBoolean(true)) {
rfc2833 = m->rfc2833().toInteger();
if (rfc2833 < 96 || rfc2833 > 127)
rfc2833 = 0;
}
}
String mline(m->fmtList());
ObjList* l = mline.split(',',false);
mline = *m;
mline << " " << (m->localPort() ? m->localPort().c_str() : "0") << " " << m->transport();
ObjList* map = m->mappings().split(',',false);
ObjList rtpmap;
ObjList* dest = &rtpmap;
String frm;
int ptime = 0;
ObjList* f = l;
for (; f; f = f->next()) {
const String* s = static_cast<const String*>(f->get());
if (s) {
int mode = 0;
if (*s == "g729b")
continue;
int payload = s->toInteger(SDPParser::s_payloads,-1);
int defcode = payload;
String tmp = *s;
tmp << "=";
bool found = false;
for (ObjList* pl = map; pl; pl = pl->next()) {
const String* mapping = static_cast<const String*>(pl->get());
if (!mapping)
continue;
if (mapping->startsWith(tmp)) {
payload = -1;
tmp = *mapping;
tmp >> "=" >> payload;
found = true;
XDebug(m_enabler,DebugAll,"RTP mapped payload %d for '%s' [%p]",
payload,s->c_str(),m_ptr);
break;
}
String tmp2 = *mapping;
int pload;
tmp2 >> "=" >> pload;
if (payload == pload) {
XDebug(m_enabler,DebugAll,"RTP conflict for payload %d, allocating new [%p]",
payload,m_ptr);
payload = -1;
u_int32_t bmap = 0;
for (ObjList* sl = map; sl; sl = sl->next()) {
mapping = static_cast<const String*>(sl->get());
if (!mapping)
continue;
tmp2 = *mapping;
pload = 0;
tmp2 >> "=" >> pload;
if (pload >= 96 && pload < 127)
bmap |= 1 << (pload - 96);
}
// allocate free and non-standard is possible
for (pload = 96; pload < 127; pload++) {
if (pload == rfc2833)
continue;
if (lookup(pload,SDPParser::s_rtpmap))
continue;
if ((bmap & (1 << (pload - 96))) == 0) {
payload = pload;
break;
}
}
if (payload >= 0)
break;
// none free, allocate from "standard" ones too
for (pload = 96; pload < 127; pload++) {
if (pload == rfc2833)
continue;
if ((bmap & (1 << (pload - 96))) == 0) {
payload = pload;
break;
}
}
break;
}
}
if (payload >= 0) {
if (!found) {
tmp = *s;
tmp << "=" << payload;
map->append(new String(tmp));
}
if (defcode < 0)
defcode = payload;
const char* map = lookup(defcode,SDPParser::s_rtpmap);
if (map && m_parser->m_codecs.getBoolValue(*s,defcodecs && DataTranslator::canConvert(*s))) {
if (*s == "ilbc20")
ptime = mode = 20;
else if (*s == "ilbc30")
ptime = mode = 30;
frm << " " << payload;
String* temp = new String("rtpmap:");
*temp << payload << " " << map;
dest = dest->append(temp);
if (mode) {
temp = new String("fmtp:");
*temp << payload << " mode=" << mode;
dest = dest->append(temp);
}
if (*s == "g729") {
temp = new String("fmtp:");
*temp << payload << " annexb=" <<
((0 != l->find("g729b")) ? "yes" : "no");
dest = dest->append(temp);
}
else if (*s == "amr") {
temp = new String("fmtp:");
*temp << payload << " octet-align=0";
dest = dest->append(temp);
}
else if (*s == "amr-o") {
temp = new String("fmtp:");
*temp << payload << " octet-align=1";
dest = dest->append(temp);
}
}
}
}
}
