aodv.java

jsim simulator program for MANET

        if(aodv_rreq.rq_src == (long)router_id)
        {
            if(isDebugEnabled() && (isDebugEnabledAt(3) || isDebugEnabledAt(1)))
                debug(" got my own REQUEST: " + aodv_rreq);
            return;
        }
        if(id_lookup(aodv_rreq.rq_src, aodv_rreq.rq_bcast_id))
        {
            if(isDebugEnabled() && (isDebugEnabledAt(3) || isDebugEnabledAt(1)))
                debug(" discarding request: " + aodv_rreq);
            return;
        }
        id_insert(aodv_rreq.rq_src, aodv_rreq.rq_bcast_id);
        double d = getTime();
        AODV_RTEntry aodv_rtentry = rt_lookup(aodv_rreq.rq_src);
        if(aodv_rtentry == null)
            aodv_rtentry = rt_add(aodv_rreq.rq_src);
        if(aodv_rtentry.set_expire(d + 6D))
            aodv_addRTEntry(aodv_rtentry.rt_dst, inetpacket.getSource(), 6D, i);
        if(aodv_rreq.rq_src_seqno > aodv_rtentry.rt_seqno || aodv_rreq.rq_src_seqno == aodv_rtentry.rt_seqno && aodv_rreq.rq_hop_count < aodv_rtentry.rt_hops)
        {
            aodv_rtentry.rt_update(aodv_rreq.rq_src_seqno, aodv_rreq.rq_hop_count, inetpacket.getSource());
            if(aodv_rtentry.rt_req_timeout > 0.0D)
            {
                aodv_rtentry.rt_req_cnt = 0;
                aodv_rtentry.rt_req_timeout = 0.0D;
                aodv_rtentry.rt_req_last_ttl = aodv_rreq.rq_hop_count;
                aodv_rtentry.rt_expire = d + 30D;
            }
            aodv_addRTEntry(aodv_rreq.rq_src, inetpacket.getSource(), 30D, i);
            InetPacket inetpacket1;
            while((inetpacket1 = aodv_pkt_deque(aodv_rtentry.rt_dst)) != null) 
                if(aodv_rtentry.rt_flags == 1)
                    aodv_delay_forward(aodv_rtentry, inetpacket1, 0.0D, false);
        }
        AODV_RTEntry aodv_rtentry1 = rt_lookup(aodv_rreq.rq_dst);
        if(aodv_rreq.rq_dst == (long)router_id)
        {
            if(isDebugEnabled() && (isDebugEnabledAt(3) || isDebugEnabledAt(1)))
                debug(" destination sending reply: ");
            seqno = seqno <= aodv_rreq.rq_dst_seqno ? aodv_rreq.rq_dst_seqno + 1 : seqno + 1;
            if(seqno % 2 == 1)
                seqno++;
            sendReply(aodv_rreq.rq_src, 1, router_id, seqno, 30D, aodv_rreq.rq_timestamp);
        } else
        if(aodv_rtentry1 != null && aodv_rtentry1.rt_hops != 0x7fffffff && aodv_rtentry1.rt_seqno >= aodv_rreq.rq_dst_seqno)
        {
            sendReply(aodv_rreq.rq_src, aodv_rtentry1.rt_hops + 1, aodv_rreq.rq_dst, aodv_rtentry1.rt_seqno, aodv_rtentry1.rt_expire - d, aodv_rreq.rq_timestamp);
            aodv_rtentry1.pc_insert(aodv_rtentry.rt_nexthop);
            aodv_rtentry.pc_insert(aodv_rtentry1.rt_nexthop);
        } else
        {
            AODV_RREQ aodv_rreq1 = (AODV_RREQ)aodv_rreq.clone();
            inetpacket.setSource(router_id);
            inetpacket.setDestination(0x7ffffffffffffffeL);
            aodv_rreq1.rq_hop_count++;
            if(aodv_rtentry1 != null)
                aodv_rreq1.rq_dst_seqno = aodv_rtentry1.rt_seqno <= aodv_rreq1.rq_dst_seqno ? aodv_rreq1.rq_dst_seqno : aodv_rtentry1.rt_seqno;
            aodv_delay_broadcast(1, aodv_rreq1, aodv_rreq1.size(), 1, null, 1.0D * rand.nextDouble(), true);
        }
    }

    protected void recvReply(AODV_RREP aodv_rrep, InetPacket inetpacket)
    {
        int i = inetpacket.getIncomingIf();
        if(isDebugEnabled() && (isDebugEnabledAt(4) || isDebugEnabledAt(1)))
            debug(" recv RREP: " + aodv_rrep + "ipkt: " + inetpacket);
        boolean flag = false;
        double d = 0.0D;
        double d1 = getTime();
        AODV_RTEntry aodv_rtentry = rt_lookup(aodv_rrep.rp_dst);
        if(aodv_rtentry == null)
            aodv_rtentry = rt_add(aodv_rrep.rp_dst);
        if(aodv_rtentry.rt_seqno < aodv_rrep.rp_dst_seqno || aodv_rtentry.rt_seqno == aodv_rrep.rp_dst_seqno && aodv_rtentry.rt_hops > aodv_rrep.rp_hop_count)
        {
            aodv_rtentry.rt_update(aodv_rrep.rp_dst_seqno, aodv_rrep.rp_hop_count, inetpacket.getSource(), d1 + aodv_rrep.rp_lifetime);
            aodv_addRTEntry(aodv_rrep.rp_dst, inetpacket.getSource(), aodv_rrep.rp_lifetime, i);
            aodv_rtentry.rt_req_cnt = 0;
            aodv_rtentry.rt_req_timeout = 0.0D;
            aodv_rtentry.rt_req_last_ttl = aodv_rrep.rp_hop_count;
            if(inetpacket.getDestination() == (long)router_id)
            {
                aodv_rtentry.rt_disc_latency[aodv_rtentry.hist_indx] = (d1 - aodv_rrep.rp_timestamp) / (double)aodv_rrep.rp_hop_count;
                aodv_rtentry.hist_indx = (aodv_rtentry.hist_indx + 1) % 3;
            }
            InetPacket inetpacket1;
            while((inetpacket1 = aodv_pkt_deque(aodv_rtentry.rt_dst)) != null) 
                if(aodv_rtentry.rt_hops != 0x7fffffff)
                {
                    if(isDebugEnabled() && (isDebugEnabledAt(8) || isDebugEnabledAt(1)))
                        debug("ready to send buffered pkt " + inetpacket1 + " rt:" + aodv_rtentry);
                    aodv_delay_forward(aodv_rtentry, inetpacket1, d, false);
                    d += 0.01D;
                }
        } else
        {
            flag = true;
        }
        if(inetpacket.getDestination() != (long)router_id && !flag)
        {
            AODV_RREP aodv_rrep1 = (AODV_RREP)aodv_rrep.clone();
            AODV_RTEntry aodv_rtentry1 = rt_lookup(inetpacket.getDestination());
            if(aodv_rtentry1 != null && aodv_rtentry1.rt_hops != 0x7fffffff)
            {
                aodv_rrep1.rp_hop_count++;
                aodv_rrep1.rp_src = router_id;
                aodv_delay_forward(2, aodv_rrep1, aodv_rrep1.size(), 1, aodv_rtentry1, 0.0D, false);
                aodv_rtentry.pc_insert(aodv_rtentry1.rt_nexthop);
            } else
            {
                if(isDebugEnabled() && (isDebugEnabledAt(4) || isDebugEnabledAt(1)))
                    debug(" dropping Route Reply: " + aodv_rrep);
                if(isGarbageEnabled())
                    drop(inetpacket, "DROP_RTR_NO_ROUTE");
            }
        }
    }

    public void recvError(AODV_RERR aodv_rerr, InetPacket inetpacket)
    {
        if(isDebugEnabled() && (isDebugEnabledAt(5) || isDebugEnabledAt(1)))
            debug(" recv RERR: " + aodv_rerr + " ipkt: " + inetpacket);
        double d = getTime();
        AODV_RERR aodv_rerr1 = new AODV_RERR();
        aodv_rerr1.DestCount = 0;
        for(int i = 0; i < aodv_rerr.DestCount; i++)
        {
            AODV_RTEntry aodv_rtentry = rt_lookup(aodv_rerr.unreachable_dst[i]);
            if(aodv_rtentry != null && aodv_rtentry.rt_hops != 0x7fffffff && aodv_rtentry.rt_nexthop == inetpacket.getSource() && aodv_rtentry.rt_seqno <= aodv_rerr.unreachable_dst_seqno[i])
            {
                if(isDebugEnabled() && (isDebugEnabledAt(5) || isDebugEnabledAt(1)))
                    debug("dst: " + aodv_rtentry.rt_dst + " seq: " + aodv_rtentry.rt_seqno + " nexthop: " + aodv_rtentry.rt_nexthop + " unreach dst: " + aodv_rerr.unreachable_dst[i] + " unreach dst seq: " + aodv_rerr.unreachable_dst_seqno[i] + " src: " + inetpacket.getSource());
                aodv_rtentry.rt_seqno = aodv_rerr.unreachable_dst_seqno[i];
                aodv_rtentry.rt_down();
                aodv_removeRTEntry(aodv_rtentry.rt_dst);
                if(!aodv_rtentry.pc_empty())
                {
                    aodv_rerr1.unreachable_dst[aodv_rerr1.DestCount] = aodv_rtentry.rt_dst;
                    aodv_rerr1.unreachable_dst_seqno[aodv_rerr1.DestCount] = aodv_rtentry.rt_seqno;
                    aodv_rerr1.DestCount++;
                    aodv_rtentry.pc_delete();
                }
            }
        }

        if(aodv_rerr1.DestCount > 0)
            sendError(aodv_rerr1, true);
    }

    public void recvHello(AODV_RREP aodv_rrep, InetPacket inetpacket)
    {
        double d = getTime();
        AODV_BroadcastID aodv_broadcastid = nb_lookup(aodv_rrep.rp_dst);
        if(aodv_broadcastid == null)
        {
            nb_insert(aodv_rrep.rp_dst);
            if(isDebugEnabled() && (isDebugEnabledAt(6) || isDebugEnabledAt(1)))
                debug(" recv Hello from new nbr: " + aodv_rrep);
        } else
        {
            aodv_broadcastid.expire = d + 4.5D;
        }
    }

    protected void sendRequest(long l)
    {
        double d = getTime();
        AODV_RREQ aodv_rreq = new AODV_RREQ();
        AODV_RTEntry aodv_rtentry = rt_lookup(l);
        if(aodv_rtentry.rt_flags == 1)
            return;
        if(aodv_rtentry.rt_req_timeout > d)
            return;
        if(aodv_rtentry.rt_req_cnt > 3)
        {
            aodv_rtentry.rt_req_timeout = d + 10D;
            aodv_rtentry.rt_req_cnt = 0;
            InetPacket inetpacket;
            while((inetpacket = aodv_pkt_deque(aodv_rtentry.rt_dst)) != null) 
                if(isGarbageEnabled())
                    drop(inetpacket, "DROP_RTR_NO_ROUTE");
            return;
        }
        aodv_rtentry.rt_req_last_ttl = aodv_rtentry.rt_req_last_ttl <= aodv_rtentry.rt_last_hop_count ? aodv_rtentry.rt_last_hop_count : aodv_rtentry.rt_req_last_ttl;
        int i;
        if(aodv_rtentry.rt_req_last_ttl == 0)
            i = 1;
        else
        if(aodv_rtentry.rt_req_last_ttl < 7)
        {
            i = aodv_rtentry.rt_req_last_ttl + 2;
        } else
        {
            i = 35;
            aodv_rtentry.rt_req_cnt++;
        }
        aodv_rtentry.rt_req_last_ttl = i;
        aodv_rtentry.rt_req_timeout = 2D * (double)i * PerHopTime(aodv_rtentry);
        if(aodv_rtentry.rt_req_cnt > 0)
            aodv_rtentry.rt_req_timeout *= aodv_rtentry.rt_req_cnt;
        aodv_rtentry.rt_req_timeout += d;
        if(aodv_rtentry.rt_req_timeout > d + 10D)
            aodv_rtentry.rt_req_timeout = d + 10D;
        aodv_rtentry.rt_expire = 0.0D;
        aodv_rreq.rq_type = 1;
        aodv_rreq.rq_hop_count = 1;
        aodv_rreq.rq_bcast_id = bid++;
        aodv_rreq.rq_dst = l;
        aodv_rreq.rq_dst_seqno = aodv_rtentry != null ? aodv_rtentry.rt_seqno : 0;
        aodv_rreq.rq_src = router_id;
        seqno += 2;
        aodv_rreq.rq_src_seqno = seqno;
        aodv_rreq.rq_timestamp = d;
        if(isDebugEnabled() && (isDebugEnabledAt(3) || isDebugEnabledAt(1)))
            debug(" sending Route Request, dst:" + l + " timeout: " + (aodv_rtentry.rt_req_timeout - d) + " rt: " + aodv_rtentry.rt_req_last_ttl + " rq: " + aodv_rreq);
        aodv_message_broadcast(1, aodv_rreq, aodv_rreq.size(), i);
    }

    protected void sendReply(long l, int i, long l1, int j, double d, double d1)
    {
        double d2 = getTime();
        AODV_RREP aodv_rrep = new AODV_RREP();
        AODV_RTEntry aodv_rtentry = rt_lookup(l);
        if(aodv_rtentry == null)
        {
            if(isDebugEnabled())
                debug("ERROR! reverse rt is null");
            return;
        }
        aodv_rrep.rp_type = 2;
        aodv_rrep.rp_hop_count = i;
        aodv_rrep.rp_dst = l1;
        aodv_rrep.rp_dst_seqno = j;
        aodv_rrep.rp_src = router_id;
        aodv_rrep.rp_lifetime = d;
        aodv_rrep.rp_timestamp = d1;
        byte byte0 = 35;
        if(isDebugEnabled() && (isDebugEnabledAt(4) || isDebugEnabledAt(1)))
            debug(" sending Reply: " + aodv_rrep + " dst " + l);
        aodv_message_send(2, aodv_rrep, aodv_rrep.size(), l, byte0);
    }

    protected void sendError(AODV_RERR aodv_rerr, boolean flag)
    {
        double d = getTime();
        if(isDebugEnabled() && (isDebugEnabledAt(5) || isDebugEnabledAt(1)))
            debug(" sending RERR: " + aodv_rerr);
        aodv_rerr.re_type = 3;
        aodv_message_broadcast(3, aodv_rerr, aodv_rerr.size(), 1);
    }

    protected void sendHello()
    {
        double d = getTime();
        AODV_RREP aodv_rrep = new AODV_RREP();
        if(isDebugEnabled() && (isDebugEnabledAt(6) || isDebugEnabledAt(1)))
            debug(" sending Hello: " + aodv_rrep);
        aodv_rrep.rp_type = 5;
        aodv_rrep.rp_hop_count = 1;
        aodv_rrep.rp_dst = router_id;
        aodv_rrep.rp_dst_seqno = seqno;
        aodv_rrep.rp_lifetime = 4D;
        aodv_message_broadcast(5, aodv_rrep, aodv_rrep.size(), 1);
    }

    protected void aodv_message_send(int i, Object obj, int j, long l, int k)
    {
        if(isDebugEnabled() && isDebugEnabledAt(2))
            debug(PKT_TYPES[i] + " sent from " + router_id + " to " + l + ": " + obj);
        AODV_Packet aodv_packet = new AODV_Packet(i, router_id);
        aodv_packet.setBody(obj, j);
        forward(aodv_packet, router_id, l, true, k, 1L);
    }

    protected void aodv_message_broadcast(int i, Object obj, int j, int k)
    {
        AODV_Packet aodv_packet = new AODV_Packet(i, router_id);
        aodv_packet.setBody(obj, j);
        if(isDebugEnabled() && isDebugEnabledAt(2))
            debug(PKT_TYPES[i] + " broadcast from " + router_id + ": " + obj + "ttl " + k);
        broadcast(aodv_packet, router_id, 0x7ffffffffffffffeL, true, k, 1L, 0x7ffffffffffffffeL);
    }

    protected void aodv_delay_broadcast(int i, Object obj, int j, int k, AODV_RTEntry aodv_rtentry, double d, 
            boolean flag)
    {
        if(isDebugEnabled() && isDebugEnabledAt(2))
            debug("delay** " + PKT_TYPES[i] + " broadcast from " + router_id + ": " + obj + "for time " + d);
        AODV_Packet aodv_packet = new AODV_Packet(i, router_id);
        aodv_packet.setBody(obj, j);
        if(flag || d != 0.0D)
        {
            AODV_TimeOut_EVT aodv_timeout_evt = new AODV_TimeOut_EVT(6, aodv_packet);
            aodv_timeout_evt.handle = setTimeout(aodv_timeout_evt, d);
        } else
        {
            broadcast(aodv_packet, router_id, 0x7ffffffffffffffeL, true, k, 1L, 0x7ffffffffffffffeL);
        }
    }

    protected void aodv_delay_forward(int i, Object obj, int j, int k, AODV_RTEntry aodv_rtentry, double d, 
            boolean flag)
    {
        if(isDebugEnabled() && isDebugEnabledAt(2))
            debug("delay* " + PKT_TYPES[i] + " broadcast from " + router_id + ": " + obj + "for time " + d);
        AODV_Packet aodv_packet = new AODV_Packet(i, router_id);
        aodv_packet.setBody(obj, j);
        InetPacket inetpacket;
        if(flag)
            inetpacket = new InetPacket(router_id, 0x7ffffffffffffffeL, 0, k, 0, true, 1L, 0, 0, 0, aodv_packet, aodv_packet.size, 0x7ffffffffffffffeL);
        else
            inetpacket = new InetPacket(router_id, aodv_rtentry.rt_dst, 0, k, 0, true, 1L, 0, 0, 0, aodv_packet, aodv_packet.size);
        aodv_delay_forward(aodv_rtentry, inetpacket, d, flag);
    }

    protected void aodv_delay_forward(AODV_RTEntry aodv_rtentry, InetPacket inetpacket, double d, boolean flag)
    {
        double d1 = getTime();
        if(inetpacket.getTTL() == 0)
        {
            if(isGarbageEnabled())
                drop(inetpacket, "DROP_RTR_TTL");
            return;
        }
        if(aodv_rtentry != null)
            inetpacket.setNextHop(aodv_rtentry.rt_nexthop);
        if(flag)
        {
            AODV_TimeOut_EVT aodv_timeout_evt = new AODV_TimeOut_EVT(5, inetpacket);
            aodv_timeout_evt.handle = setTimeout(aodv_timeout_evt, d);
        } else
        if(d > 0.0D)
        {
            AODV_TimeOut_EVT aodv_timeout_evt1 = new AODV_TimeOut_EVT(5, inetpacket);
            aodv_timeout_evt1.handle = setTimeout(aodv_timeout_evt1, d);
        } else
        {
            downPort.doSending(inetpacket);
        }
    }

    private void nb_insert(long l)
    {
        double d = getTime();
        if(nbr_EVT == null)
        {
            nbr_EVT = new AODV_TimeOut_EVT(2, null);
            nbr_EVT.handle = setTimeout(nbr_EVT, 1.0D);
            if(isDebugEnabled() && isDebugEnabledAt(7))
                debug(" set NBR timeout: 1.0");
        }
        AODV_BroadcastID aodv_broadcastid = new AODV_BroadcastID(l);
        aodv_broadcastid.expire = d + 4.5D;
        aodv_nbr_list.addElement(aodv_broadcastid);
        seqno += 2;
    }

    private AODV_BroadcastID nb_lookup(long l)
    {
        int i = aodv_nbr_list.size();
        for(int j = 0; j < i; j++)
        {
            AODV_BroadcastID aodv_broadcastid = (AODV_BroadcastID)aodv_nbr_list.elementAt(j);
            if(aodv_broadcastid.src == l)
                return aodv_broadcastid;
        }

        return null;
    }

    private void nb_purge()
    {
        double d = getTime();
        for(int i = 0; i < aodv_nbr_list.size(); i++)
        {
            AODV_BroadcastID aodv_broadcastid = (AODV_BroadcastID)aodv_nbr_list.elementAt(i);
            if(aodv_broadcastid.expire <= d)
                nb_delete(aodv_broadcastid.src);
            else
                i++;
        }