test.click

COPE the first practical network coding scheme which is developped on click

rates :: AvailableRates(DEFAULT 2 4 11 22);

aliastable :: AliasTable();

elementclass srcr_ett {
  $srcr_ip, $srcr_nm, $wireless_mac, $gateway, $probes|

arp :: ARPTable();
lt :: LinkTable(IP $srcr_ip);

sendmgr :: SendManager(IP $srcr_ip);
recvmgr :: RecvManager(ALIASTABLE aliastable);

//gw :: GatewaySelector(ETHTYPE 0x092c,
//		      IP $srcr_ip,
//		      ETH $wireless_mac,
//		      LT lt,
//		      ARP arp,
//		      PERIOD 15,
//		      GW $gateway);


//gw -> SetSRChecksum -> [0] output;

//set_gw :: SetGateway(SEL gw);


//es :: ETTStat(ETHTYPE 0x0941, 
//	      ETH $wireless_mac, 
//	      IP $srcr_ip, 
//	      PERIOD 30000,
//	      TAU 300000,
//	      ARP arp,
//	      PROBES $probes,
//	      ETT metric,
//	      RT rates);


//metric :: ETTMetric(LT lt);


forwarder :: SRForwarder(ETHTYPE 0x0943, 
			      IP $srcr_ip, 
			      ETH $wireless_mac,
			      ARP arp,
			      LT lt);


set_sr :: SetSourceRoute(IP $srcr_ip,
			 SR forwarder);


//querier :: SRQuerier(ETH $wireless_mac, 
//		     SR forwarder,
//		     LT lt, 
//		     ROUTE_DAMPENING true,
//		     TIME_BEFORE_SWITCH 5,
//		     DEBUG true);


//tracker_forwarder :: MetricFlood(ETHTYPE 0x092e
//				 IP $srcr_ip, 
//				 ETH $wireless_mac, 
//				 LT lt, 
//				 ARP arp,
//				 DEBUG false);


//TimedSource(600, "") 
//-> SetIPAddress(255.255.255.255)
//-> [1] tracker_forwarder
//-> SetSRChecksum -> [0] output;


//tracker_forwarder [1] -> Discard;


//query_forwarder :: MetricFlood(ETHTYPE 0x0944,
//			       IP $srcr_ip, 
//			       ETH $wireless_mac, 
//			       LT lt, 
//			       ARP arp,
//			       DEBUG false);


//query_responder :: SRQueryResponder(ETHTYPE 0x0945,
//				    IP $srcr_ip, 
//				    ETH $wireless_mac, 
//				    LT lt, 
//				    ARP arp,
//				    DEBUG true);


//query_responder -> SetSRChecksum -> [0] output;
//query_forwarder -> SetSRChecksum -> PrintSR(forwarding) -> [0] output;
//query_forwarder [1] -> query_responder;

data_ck :: SetSRChecksum() 

input [1] 
-> SetTimestamp()
-> counter_incoming :: IPAddressCounter(USE_DST true)
-> host_cl :: IPClassifier(dst net $srcr_ip mask $srcr_nm,
				-)
//-> querier
-> set_sr
-> data_ck;


host_cl [1] //-> [0] set_gw [0] -> querier;
-> Discard;


               
forwarder[0] 
//-> Print("PreDecIPTTL", NBYTES 1000)
  -> dt ::DecIPTTL
  -> data_ck
//-> Print("PreSQ", NBYTES 1000)
  -> scramble_q :: ScrambleQueue(ENCETHTYPE 0x0977,
                                 ACKETHTYPE 0x0980,
				 PUREACKETHTYPE 0x0981,
                                 ETH $wireless_mac,
                                 IP $srcr_ip,
                        	 SENDMGR sendmgr,
                  		 CAPACITY 1000,
                                 RECVMGR recvmgr,
                                 ALIASTABLE aliastable)
//  -> [2] output;
// -> Print("Outgoing", NBYTES 1000)
  -> [0] output;

dt[1] 
-> Print(ttl-error) 
-> ICMPError($srcr_ip, timeexceeded, 0) 
//-> querier;
-> Discard;


// queries
//querier [1] -> [1] query_forwarder;
//es -> SetTimestamp() -> [1] output;


forwarder[1] //ip packets to me
  -> StripSRHeader()
  -> CheckIPHeader()
//  -> from_gw_cl :: IPClassifier(src net $srcr_ip mask $srcr_nm,
//				-)
  -> counter_outgoing :: IPAddressCounter(USE_SRC true)
//  -> [3] output;
-> [1] output;


//from_gw_cl [1] -> [1] set_gw [1] -> [3] output;


input [0]
-> ack_cl :: Classifier(12/098?,    // Acked packets
                        -); 
 
ackreceiver :: AckReceiver(ETH $wireless_mac,
                           ALIASTABLE aliastable,
                           SENDMGR sendmgr)

ack_cl[0] -> ackreceiver;

listenmanager :: ListenManager(ALIASTABLE aliastable, RECPTIMEOUT 5)

ack_cl[1] 
   -> listenmanager 
   -> pre_cl :: Classifier(
                           12/0977, //encoded packets, go to decoder
                           -);


pre_cl[0]
   -> PrintXor()
   -> decoder :: Decoder(ETH $wireless_mac,
                         SENDMGR sendmgr,
                         RECVMGR recvmgr,
                         ALIASTABLE aliastable)
//  -> Print("PostDecoder", NBYTES 1000)
   -> ncl :: Classifier(
			12/0943 , //srcr_forwarder
//			12/0944 , //srcr
//			12/0945 , //replies
//			12/0941 , //srcr_es
//			12/092c , //srcr_gw
//			12/092e , //srcr_tracker
			-
			);

                           

pre_cl[1] 
-> ackunenc :: AckUnencoded(RECVMGR recvmgr) -> ncl;
 
 
ncl[0] -> ch_f :: CheckSRHeader() -> [0] forwarder;
//ncl[1] -> CheckSRHeader() -> PrintSR(query) -> query_forwarder
//ncl[2] -> CheckSRHeader() -> query_responder;
//ncl[3] -> es;
//ncl[4] -> CheckSRHeader() -> gw;
//ncl[5] -> CheckSRHeader() 
//-> tracker :: FloodTracker()
//-> tracker_forwarder;
ncl[1] -> Discard;
 
}


// has one input and one output
// takes and spits out ip packets

elementclass LinuxHost {
    $dev, $ip, $nm, $mac |
    input -> ToHost($dev);
    FromHost($dev, $ip/$nm, ETHER $mac) -> output;
}


// has one input and one output
// takes and spits out ip packets
elementclass LinuxIPHost {
    $dev, $ip, $nm |

  input -> KernelTun($ip/$nm, MTU 1500, DEV_NAME $dev) 
  -> MarkIPHeader(0)
  -> CheckIPHeader()
  -> output;

}

elementclass SniffDevice {
    $device, $promisc|
	// we only want txf for NODS packets
	// ether[2:2] == 0x1200 means it has an ath_rx_radiotap header (it is 18 bytes long)
	// ether[2:2] == 0x1000 means it has an ath_tx_radiotap header (it is 16 bytes long)
	// ether[18] == 0x08 means NODS
  from_dev :: FromDevice($device, 
			 PROMISC $promisc) 
  -> output;
  input -> to_dev :: ToDevice($device);
}

control :: ControlSocket("TCP", 7777);
chatter :: ChatterSocket("TCP", 7778);
sniff_dev :: SniffDevice(eth0, true);

sched :: PrioSched()
-> set_power :: SetTXPower(POWER 60)
-> radiotap_encap :: RadiotapEncap()
-> sniff_dev;

//route_q :: FullNoteQueue(10) 
//-> [0] sched;

//data_q :: FullNoteQueue(10)
data_encap :: WifiEncap(0x0, 00:00:00:00:00:00)
-> data_static_rate :: SetTXRate(RATE 2)
-> data_madwifi_rate :: MadwifiRate(OFFSET 4,
			       ALT_RATE true,
			       RT rates,
			       ACTIVE true)
//-> data_adjust_rate :: AdjustRate(ETHTYPE 0x0977,
//				  IP 5.121.106.137,
//				  ETH 00:11:11:79:6A:89,
//				  ARP "srcr/arp",
//				  OFFSET 0)
-> data_arf_rate :: AutoRateFallback(OFFSET 4,
				STEPUP 25,
				RT rates,
				ACTIVE false)
-> data_probe_rate :: ProbeTXRate(OFFSET 4,
			     WINDOW 5000,
			     RT rates,
			     ACTIVE false)
-> temp_rate :: SetTXRate (RATE 2)
// change rate to 4, 11 or 22 during fixed rate experiments
// comment this line OUT when you use rate adaptation from the card driver 
//-> [1] sched;
-> [0] sched;


Idle -> [1] data_probe_rate;
Idle -> [1] data_madwifi_rate;
Idle -> [1] data_arf_rate;



srcr :: srcr_ett(5.121.106.137, 255.0.0.0, 00:11:11:79:6A:89, false, 
		 "2 60 2 1500 4 1500 11 1500 22 1500");


// make sure this is listed first so it gets tap0
srcr_host :: LinuxIPHost(srcr, 5.121.106.137, 255.0.0.0)
-> [1] srcr;


//route_encap :: WifiEncap(0x0, 00:00:00:00:00:00)
//->  route_q;
//data_encap :: WifiEncap(0x0, 00:00:00:00:00:00)
//-> data_q;

//srcr [0] -> route_encap;   // queries, replies
//srcr [1] -> route_encap;   // bcast_stats
srcr [0] -> data_encap;    // data
srcr [1] -> srcr_host; // data to me



sniff_dev 
-> prism2_decap :: Prism2Decap()
-> phyerr_filter :: FilterPhyErr()
-> extra_decap :: ExtraDecap()
-> radiotap_decap :: RadiotapDecap()
//-> PrintWifi(fromdev)
-> beacon_cl :: Classifier(0/80, //beacons
			    -)
-> bs :: BeaconScanner(RT rates)
-> Discard;

beacon_cl [1]
-> Classifier(0/08%0c) //data
-> tx_filter :: FilterTX()
-> dupe :: WifiDupeFilter() 
-> WifiDecap()
-> ackfilter :: AckFilter(ETHTYPE 0x0980,
			  PUREACKETHTYPE 0x0981);

ackfilter [0]
-> enc_cl :: Classifier(12/0977, -);

ackfilter [1] 
-> ncl :: Classifier(
		     12/09??,
		     -);

enc_cl [0]
-> EncHostEtherFilter(ETH 00:11:11:79:6A:89, ALIASTABLE aliastable, DROP_OTHER true, DROP_OWN true)
-> rxstats :: RXStats();

enc_cl [1]
-> HostEtherFilter(00:11:11:79:6A:89, DROP_OTHER true, DROP_OWN true) 
-> rxstats
-> ncl;

ncl [0] -> srcr;

ncl[1] 
-> Discard;
tx_filter [1] 
//-> PrintWifi(txf)
-> txf_t2 :: Tee(3);

txf_t2 [0] -> [1] data_arf_rate;
txf_t2 [1] -> [1] data_madwifi_rate;
txf_t2 [2] -> [1] data_probe_rate;