/* PSIPHON: entire function */
static int
tunnelSplitTunnelingDnsHandler(int status, GethostbynameRequestPtr request)
{
TunnelPtr tunnel = request->data;
if(status <= 0) {
tunnelError(tunnel, 504,
internAtomError(-status,
"Host %s lookup failed",
atomString(tunnel->hostname)));
return 1;
}
if(request->addr->string[0] == DNS_CNAME) {
if(request->count > 10)
tunnelError(tunnel, 504, internAtom("CNAME loop"));
do_gethostbyname_socks(request->addr->string + 1, request->count + 1,
tunnelSplitTunnelingDnsHandler, tunnel);
return 1;
}
//Get IP from the request, check against our local networks list
int local_addr = 0;
if(request->addr->string[0] == DNS_A)
{
HostAddressPtr host_addr;
host_addr = (HostAddressPtr) &request->addr->string[1];
//we deal only with IPv4 addresses
if(host_addr->af == 4)
{
struct in_addr servaddr;
memcpy(&servaddr.s_addr, &host_addr->data, sizeof(struct in_addr));
local_addr = isLocalAddress(servaddr);
}
}
if (local_addr != 0)
{
printf("PSIPHON-UNPROXIED:>>%s<<", request->name->string);
fflush(NULL);
}
//Use SOCKS for IPs that are not local and connect directly to the ones that are
//At this point the DNS record for the request should be cached, default TTL for DNS requests
//is 240 seconds
if(local_addr == 0)
{
do_socks_connect(parentHost ?
parentHost->string : tunnel->hostname->string,
parentHost ? parentPort : tunnel->port,
tunnelSocksHandler, tunnel);
}
else
{
do_connect(retainAtom(request->addr), 0,
parentHost ? parentPort : tunnel->port,
tunnelConnectionHandler, tunnel);
}
return 1;
}
void AbstractEARAClient::addEnergyInformationToPacket(Packet* packet) {
if (isLocalAddress(packet->getSource()) == false) {
// only add the energy value if this is relayed by an intermediate node
EARAPacket* earaPacket = static_cast<EARAPacket*>(packet);
unsigned int energyOfCurrentNode = getCurrentEnergyLevel();
earaPacket->addEnergyValue(energyOfCurrentNode);
}
}
void AbstractEARAClient::updateRoutingTable(Packet* packet, NetworkInterface* interface) {
AddressPtr source = packet->getSource();
AddressPtr sender = packet->getSender();
if (packet->isAntPacket() && isLocalAddress(packet->getPreviousHop()) == false
&& routingTable->isNewRoute(source, sender, interface) == false) {
// trigger the evaporation first so this does not effect the new route or update
routingTable->triggerEvaporation();
// the route for this ant packet needs to be reinforced so we can completely replace the energy values
float currentPheromoneValue = routingTable->getPheromoneValue(source, sender, interface);
float newPheromoneValue = pathReinforcementPolicy->calculateReinforcedValue(currentPheromoneValue);
float newEnergyValue = calculateInitialEnergyValue(static_cast<EARAPacket*>(packet));
routingTable->update(source, sender, interface, newPheromoneValue, newEnergyValue);
}
else {
AbstractARAClient::updateRoutingTable(packet, interface);
}
}
int FBtnCalc::PositionRun( QVector<RealFde>& frames_ltrb, QVector<RealFde>& frames_margin_ltrb, QVector<RealFde>& primitive_ltrb )
{
int ret = 0;
//////////////////////////////
// Use Calculation Scheme
//////////////////////////////
//QVector<double> ev_stack;
MArray<double> ev_stack(64, 0, 64);
long ev_stack_top = 0;
FBtnPiCode *cmd;
for( long i = 0; i < size(); i++ )
{
cmd = &((*this)[i]);
switch( cmd->command )
{
case LPC_ASIGN:
if( isLocalAddress( cmd->frame_var.first ) )
{
ret = isParentMarginAddr( cmd->frame_var.second );
locals[ cmd->frame_var.second ] = (RealFde) ev_stack[ --ev_stack_top ];
}
else if( isPrimitiveAddress( cmd->frame_var.first ) )
primitive_ltrb[ (- cmd->frame_var.first - 1) * 4 + cmd->frame_var.second ] = (RealFde) ev_stack[ --ev_stack_top ];
else if( isFrameAddress( cmd->frame_var.first ) && isMargin( cmd->frame_var.second ) )
{
frames_margin_ltrb[ (cmd->frame_var.first - 1) * 4 + (cmd->frame_var.second + 4) ] = (RealFde) ev_stack[ --ev_stack_top ];
ret = 1;
}
break;
case LPC_POP:
--ev_stack_top;
break;
case LPC_PUSH:
if( isFrameAddress( cmd->frame_var.first ) )
{
if( isMargin( cmd->frame_var.second ) )
ev_stack[ ev_stack_top++ ] =
frames_margin_ltrb[ (cmd->frame_var.first - 1) * 4 + (cmd->frame_var.second + 4) ];
else
ev_stack[ ev_stack_top++ ] =
frames_ltrb[ (cmd->frame_var.first - 1) * 4 + cmd->frame_var.second ];
}
else if( isLocalAddress( cmd->frame_var.first ) )
ev_stack[ ev_stack_top++ ] = locals[ cmd->frame_var.second ];
else if( isPrimitiveAddress( cmd->frame_var.first ) )
ev_stack[ ev_stack_top++ ] = primitive_ltrb[ (- cmd->frame_var.first - 1) * 4 + cmd->frame_var.second ];
break;
case LPC_PUSHVAL:
ev_stack[ ev_stack_top++ ] = cmd->val;
break;
case LPC_MINUS:
ev_stack[ ev_stack_top - 1 ] = - ev_stack[ ev_stack_top - 1 ];
break;
case LPC_ADD:
ev_stack_top--;
ev_stack[ ev_stack_top - 1 ] = ev_stack[ ev_stack_top - 1 ] + ev_stack[ ev_stack_top ];
break;
case LPC_SUB:
ev_stack_top--;
ev_stack[ ev_stack_top - 1 ] = ev_stack[ ev_stack_top - 1 ] - ev_stack[ ev_stack_top ];
break;
case LPC_MUL:
ev_stack_top--;
ev_stack[ ev_stack_top - 1 ] = ev_stack[ ev_stack_top - 1 ] * ev_stack[ ev_stack_top ];
break;
case LPC_DIV:
ev_stack_top--;
ev_stack[ ev_stack_top - 1 ] = ev_stack[ ev_stack_top - 1 ] / ev_stack[ ev_stack_top ];
break;
case LPC_AVERAGE:
ev_stack_top--;
ev_stack[ ev_stack_top - 1 ] = (ev_stack[ ev_stack_top - 1 ] + ev_stack[ ev_stack_top ]) / 2.0;
break;
case LPC_MIN:
ev_stack_top--;
ev_stack[ ev_stack_top - 1 ] = ev_stack[ ev_stack_top - 1 ] > ev_stack[ ev_stack_top ] ?
ev_stack[ ev_stack_top ] : ev_stack[ ev_stack_top - 1 ];
break;
case LPC_MAX:
ev_stack_top--;
ev_stack[ ev_stack_top - 1 ] = ev_stack[ ev_stack_top - 1 ] > ev_stack[ ev_stack_top ] ?
ev_stack[ ev_stack_top - 1 ] : ev_stack[ ev_stack_top ];
break;
default:
break;
}
}
return ret;
}
RoutingDecision_e routePacket(MacInfo_t *info)
{
MosAddr *dst = &info->originalDst;
// PRINTF("route: dst address=0x%04x, nexthop=0x%04x\n", dst->shortAddr, info->immedDst.shortAddr);
// PRINTF(" localAddress=0x%04x\n", localAddress);
if (IS_LOCAL(info)) {
// fix root address if we are sending it to the root
if (dst->shortAddr == MOS_ADDR_ROOT) {
intToAddr(info->originalDst, rootAddress);
// info->hoplimit = hopCountToRoot;
info->hoplimit = MAX_HOP_COUNT;
}
} else {
// PRINTF("route packet, addr=0x%04x port=%02x\n", dst->shortAddr, info->dstPort);
uint8_t index = markAsSeen(info->immedSrc.shortAddr, false);
if (index != 0xff) {
uint32_t expectedTimeStart = 4000ul + MOTE_TIME_FULL * index + MOTE_TIME
+ (IS_ODD_COLLECTOR ? MOTE_TIME_FULL * MAX_MOTES : 0);
uint32_t expectedTimeEnd = expectedTimeStart + MOTE_TIME;
uint32_t now = timeSinceFrameStart();
if (now < expectedTimeStart || now > expectedTimeEnd) {
TPRINTF("*** mote %#04x sends out of its time: expected at %lu (+0-512 ms), now %lu!\n",
motes[index].address, expectedTimeStart, now);
}
} else {
if (timeSinceFrameStart() > 4000) {
TPRINTF("*** unregistered sender!\n");
}
}
}
if (isLocalAddress(dst)) {
INC_NETSTAT(NETSTAT_PACKETS_RECV, info->originalSrc.shortAddr);
return RD_LOCAL;
}
if (isBroadcast(dst)) {
fillLocalAddress(&info->immedSrc); // XXX
if (!IS_LOCAL(info)){
INC_NETSTAT(NETSTAT_PACKETS_RECV, info->originalSrc.shortAddr);
}
// don't forward broadcast packets
return IS_LOCAL(info) ? RD_BROADCAST : RD_LOCAL;
}
// check if hop limit allows the packet to be forwarded
if (!checkHoplimit(info)) {
PRINTF("hoplimit reached!\n");
return RD_DROP;
}
// fill address: may forward it
fillLocalAddress(&info->immedSrc);
if (dst->shortAddr == rootAddress) {
if (isRoutingInfoValid()) {
//PRINTF("using 0x%04x as nexthop to root\n", nexthopToRoot);
if (!IS_LOCAL(info)) {
#if PRECONFIGURED_NH_TO_ROOT
if (info->immedDst.shortAddr != localAddress) {
TPRINTF("Dropping, I'm not a nexthop for sender %#04x\n",
info->originalSrc.shortAddr);
INC_NETSTAT(NETSTAT_PACKETS_DROPPED_RX, EMPTY_ADDR);
return RD_DROP;
}
#endif
// if (info->hoplimit < hopCountToRoot){
// PRINTF("Dropping, can't reach host with left hopCounts\n");
// return RD_DROP;
// }
TPRINTF("****** Forwarding a packet to root for %#04x!\n",
info->originalSrc.shortAddr);
INC_NETSTAT(NETSTAT_PACKETS_FWD, nexthopToRoot);
// delay a bit
info->timeWhenSend = getSyncTimeMs() + randomNumberBounded(150);
} else{
//INC_NETSTAT(NETSTAT_PACKETS_SENT, nexthopToRoot); // Done @ comm.c
}
info->immedDst.shortAddr = nexthopToRoot;
return RD_UNICAST;
} else {
// PRINTF("root routing info not present or expired!\n");
TPRINTF("DROP\n");
return RD_DROP;
}
}
if (IS_LOCAL(info)) {
//INC_NETSTAT(NETSTAT_PACKETS_SENT, dst->shortAddr); // Done @ comm.c
// send out even with an unknown nexthop, makes sense?
return RD_UNICAST;
}
return RD_DROP;
}
