[Click] [CLICK] HELP!!!! PROBLEMS WITH DSDV in USER LEVEL

[kamaldeep R.V]

I have 3 wireless Routers ,with IP addresses 192.168.20.1 ,192.168.20.2 and
192.168.20.3 respectively.[router 1 can see router 2, and router 3 can see
router2, but router1 cannot see
router3]
I have installed the latest Click by giving --disable-linuxmodule
--enable-grid --enable-userlevel --enable-wifi --enable-analysis
as the configuration options.

Then i did make and make install and then generated the dsdv.click file
using the make-dsdv-config.pl -a 192.168.20.x --metric etx -i ath0 -u >
/tmp/dsdv.click

but after i run click on the 3 routers i am able to ping single hop but not
multi hop.
And when i do "printf 'read nb.rtes\nquit\n' | nc localhost 7777" on router
3 i am able to see the entry for router 1 and router2 with hops 2 and 1
respectively, and their corresponding
ETX metric values.








// This file automatically generated at Tue Nov 14 22:08:05 EST 2006 with
the following command:
// make-dsdv-config.pl --metric etx -i ath0 -a 192.168.20.3 -u

// this configuration performs routing lookup *after* the interface
// queue, and only works with one interface.

AddressInfo(me 192.168.20.3 00:14:6C:15:D6:BA);

elementclass TTLChecker {
  // expects grid packets with MAC headers --- place on output path to
  // decrement the IP TTL for next hop and provide traceroute support.
  //
  // push -> push
  //
  // output [0] passes through the Grid MAC packets
  //
  // output [1] produces ICMP error packets to be passed back to IP
  // routing layer

  input -> cl :: Classifier(19/03, -);
  cl [1] -> output; // don't try to dec ttl for non-IP packets...

  cl [0]
    -> MarkIPHeader(82)
    -> cl2 :: IPClassifier(src host != me, -);

  cl2 [0]-> dec :: DecIPTTL; // only decrement ttl for packets we don't
originate
  cl2 [1] -> output;

  dec [0] -> output;
  dec [1] -> ICMPError(me, 11, 0) -> [1] output;
};

li :: GridLocationInfo2(0, 0, LOC_GOOD false);

elementclass FixupGridHeaders {
  $li | // LocationInfo element
  input
-> FixSrcLoc($li)
    -> SetGridChecksum
    -> output;
};

elementclass ToGridDev {
  // push, no output
  $dev |
  input -> cl :: Classifier(
                            12/7ffe, // LinkStat 1
                            12/7ffd, // LinkStat 2
                            19/02,
                           19/03 );
  prio :: PrioSched;
  cl [0] -> probe_counter :: Counter -> probe_q :: Queue(5) -> [0] prio;
  cl [1] -> probe_counter;
  cl [2] -> route_counter :: Counter -> route_q :: Queue(5) ->
FixupGridHeaders(li) -> [1] prio;
  cl [3] ->  data_counter :: Counter ->  data_q :: Queue(5)
    -> data_counter_out :: Counter
    -> tr :: TimeRange
  -> lr :: LookupLocalGridRoute2(me:eth, me:ip, nb)
    -> FixupGridHeaders(li)
    -> data_counter_out2 :: Counter
    -> tr2 :: TimeRange
    -> [2] prio;
  prio
    -> dev_counter :: Counter
    -> t :: PullTee
    -> ToDevice($dev);
  t [1] -> SetTimestamp -> Discard;
};

elementclass FromGridDev {
  // push, no input
  // `Grid' packets on first output
  // `LinkStat' packets on second output
  $dev, $mac |
  FromDevice($dev, PROMISC false)
    -> t :: Tee
    -> HostEtherFilter($mac, DROP_OWN true)
 -> cl :: Classifier(12/7fff, 12/7ffe, 12/7ffd, -);
  cl [0]  // `Grid' packets
    -> ck :: CheckGridHeader
    -> [0] output;
  cl [1]  // `LinkStat 1' packets
    -> [1] output;
  cl [2]  // `LinkStat 2' packets
    -> [1] output;
  cl [3] // everything else
    -> [2] output;
  t [1] -> Discard;
  ck [1] -> Print('Bad Grid header received', TIMESTAMP true, NBYTES 166) ->
Discard;
};

elementclass GridLoad {
  // push, no input

  // DATASIZE should be the size of the desired UDP packet (including
  // ethernet, Grid, and IP headers), plus 2 for alignment.  It must
  // be at least 120.  Most of this is stripped off to be re-used
 // encapsulation.
  src :: InfiniteSource(ACTIVE false, DATASIZE 120)
    -> Strip(112) // 14 + 60 + 8 + 20 + 8 + 2 = 112
                  // (eth + grid + grid_encap + ip + udp + 2 for alignment)
    -> seq :: IncrementSeqNo(FIRST 0, OFFSET 0)
    -> SetIPAddress(me)
    -> StoreIPAddress(4)
    -> udp :: UDPIPEncap(me, 1111, 0.0.0.0, 8021)
    -> count :: Counter
    -> tr :: TimeRange
    -> output;

  ph :: PokeHandlers;
}

ls2 :: Idle;
ls :: LinkStat(ETH me:eth, SIZE 148 );
metric :: ETXMetric(ls );

nb :: DSDVRouteTable(60000, 15000, 7500, 1000,
                     me:eth, me:ip,
                     MAX_HOPS 100,
                     METRIC metric,
                     VERBOSE false

                     );

grid_demux :: Classifier(19/03,    // encapsulated (data) packets
                         19/02);   // route advertisement packets

arp_demux :: Classifier(12/0806 20/0001, // arp queries
                        12/0800);        // IP packets

// handles IP packets with no extra encapsulation
ip_demux :: IPClassifier(dst host me,    // ip for us
                         dst net me/24); // ip for Grid network

// handles IP packets with Grid data encapsulation
grid_data_demux :: IPClassifier(dst host me,    // ip for us
 dst net me/24); // ip for Grid network

// dev0
dev0 :: ToGridDev(ath0);
from_dev0 :: FromGridDev(ath0, me:eth)
from_dev0 [0] -> Paint(0) -> grid_demux
from_dev0 [1] -> Paint(0) -> probe_cl :: Classifier(12/7ffe, 12/7ffd);

probe_cl [0] -> ls ->  probe_switch :: Switch(0) -> dev0;
probe_cl [1] -> ls2 -> probe_switch;

// support for traceroute
dec_ip_ttl :: TTLChecker -> dev0;
dec_ip_ttl [1] -> ip_demux;

grid_demux [0] -> CheckIPHeader( , 82) -> grid_data_demux;
grid_demux [1] -> nb -> dev0;

ip_input :: CheckIPHeader -> GetIPAddress(16) -> ip_demux;
;
to_host_encap :: KernelTun(me/24, HEADROOM 68, MTU 1432) -> ip_input;

// not needed in userlevel
Idle -> arp_demux [0] -> Idle;
arp_demux [1] -> Idle;

from_dev0 [2] -> Discard;

ControlSocket(tcp, 7777);

ip_demux [0] -> to_host_encap;  // loopback packet sent by us, required on
BSD userlevel
ip_demux [1] -> GridEncap(me:eth, me:ip) -> dec_ip_ttl;   // forward packet
sent by us

grid_data_demux [0] -> Strip(82) -> to_host_encap;  // receive packet from
net for us
grid_data_demux [1] -> dec_ip_ttl;                                // forward
packet from net for someone else


// UDP packet generator
load :: GridLoad -> ip_input;