View source for Brn master 20051109.click

  //
  // 802.11b access point
  //
  
  // needs INTERFACE (interface for the ap), SSID (name of the network), CHANNEL (operating channel), BEACON_INTERVAL
  // (interval for sending beacons in milliseconds)
  // input[0] from device with decap and so on, only management frames ???? filtering necessary (only packets for me?)
  // output[0] to device without encap, settx and so on
  elementclass AccessPoint {
      DSR $DSR, INTERFACE $device, SSID $ssid, CHANNEL $channel, BEACON_INTERVAL $beacon_interval |
  
      AddressInfo(ether_address $device:eth);
      winfo :: WirelessInfo(SSID $ssid, BSSID ether_address, CHANNEL $channel, INTERVAL $beacon_interval);
      rates :: AvailableRates(DEFAULT 2 4 11 12 18 22);
  
      input[0]
      -> mgt_cl :: Classifier(0/00%f0, //assoc req
                              0/10%f0, //assoc resp
            0/40%f0, //probe req
            0/50%f0, //probe resp
            0/80%f0, //beacon
            0/a0%f0, //disassoc
            0/b0%f0, //disassoc
            );
  
      mgt_cl[0]
      //-> PrintWifi("assoc_req")
      //-> AssociationResponder(WIRELESS_INFO winfo, RT rates)
      -> BRNAssocResponder(DEBUG false, WIRELESS_INFO winfo, RT rates, AssocList client_lst)
      //-> PrintWifi("assoc_reply")
      -> [0]output;
  
      mgt_cl[1]
      //-> PrintWifi("assoc_resp")
      -> Discard;
  
      mgt_cl[2]
      -> BeaconSource(WIRELESS_INFO winfo, RT rates)
      -> Discard();
      Idle()
      -> [0]output;
  
      mgt_cl[3]
      //-> PrintWifi("probe_resp")
      -> Discard;
  
      mgt_cl[4]
      -> BeaconScanner(RT rates)
      -> Discard; 
  
      mgt_cl[5]
      //-> PrintWifi("disassoc")
      -> Discard;
  
      mgt_cl[6]
      //-> PrintWifi("auth")
      -> OpenAuthResponder(WIRELESS_INFO winfo)
      //-> PrintWifi("auth_reply")
      -> [0]output;
  }
  
  //
  // BRN Dynamic Source Routing
  //
  
  // input[0] - ethernet (802.3) frames from external nodes (no BRN protocol)
  // input[1] - BRN DSR packets from internal nodes
  // input[2] - failed transmission of a BRN DSR packet (broken link) from ds
  // [0]output - ethernet (802.3) frames to external nodes/clients or me (no BRN protocol)
  // [1]output - BRN DSR packets to internal nodes (BRN DSR protocol)
  elementclass DSR {$DEVICE_1, $DEVICE_2, $DEVICE_3 |
  
    //
    // definitions
    //
    rc :: BrnRouteCache(ACTIVE false,
      DROP /* 1/20 = 5% */ 0, SLICE /* 100ms */ 0, TTL /* 4*100ms */4);
    lt :: BrnLinkTable(rc);
    id :: NodeIdentity($DEVICE_1, $DEVICE_2, $DEVICE_3, lt);
    brn_encap :: BRNEncap;
    dsr_decap :: DSRDecap(id, lt);
    dsr_encap :: DSREncap(id, lt);
    nb :: DstClassifier(id, client_lst);
    querier :: RouteQuerier(lt, dsr_encap, brn_encap, dsr_decap);
    req_forwarder :: RequestForwarder(id, lt, dsr_decap, dsr_encap, brn_encap, querier, client_lst);
    rep_forwarder :: ReplyForwarder(id, dsr_decap, querier, client_lst, dsr_encap, lt);
    src_forwarder :: SrcForwarder(id, client_lst, dsr_encap, dsr_decap, lt);
    err_forwarder :: ErrorForwarder(id, lt, client_lst, dsr_encap, dsr_decap, querier, brn_encap);
  
    // ------------------
    // external packets
    // ------------------
    input[0]
    //-> Print(XXXXX)
    -> clf_bcast :: Classifier(0/ffffffffffff, -); // broadcast & unicast packets
  
    clf_bcast[0]
    -> Discard;
  
    clf_bcast[1]
    //-> Print(from_ext_node)
    -> nb;
  
    nb[0] // packet is for me
    -> [0]output;
  
    nb[1] // packet for associated client (external)
    -> [0]output;
  
    nb[2] // packet for internal nodes
    //-> Print(dest_far_away)
    -> querier;
  
    querier[0]-> [1]output; // rreq packets (broadcast)
    querier[1]-> [0]src_forwarder; // src routed packets (unicast)
  
    src_forwarder[0]
    //-> Print(forward_packet)
    -> [1]output;
  
    src_forwarder[1]
    //-> Print(for_me_or_assoc_client)
    -> [0]output;
  
    // ------------------
    // internal packets
    // ------------------
    input[1]
    //-> $NB_LST // collect information about neighbors
    //-> NeighborList($NB_LST)
    -> dsrclf :: Classifier(6/01, //DSR_RREQ
                            6/02, //DSR_RREP
                            6/03, //DSR_RERR
                            6/04, //DSR_SRC
                            );
  
    dsrclf[0]
    //-> Print(rreq)
    -> req_forwarder[0]
    -> [1]output;
  
    req_forwarder[1]
    //-> BRNPrint(to_replier)
    -> [0]rep_forwarder
    -> [1]output;
  
    dsrclf[1]
    //-> Print(reply)
    -> [1]rep_forwarder;
  
    dsrclf[2]
    //-> Print(error)
    -> [1]err_forwarder
    -> [1]output;
  
    dsrclf[3]
    //-> Print(dsr_src)
    -> [1]src_forwarder;
  
    // ------------------
    // undeliverable packets
    // ------------------
    input[2]
    -> [0]err_forwarder;
  }
  
  //
  // BRN DHCP
  //
  
  // input  - broadcast packets (no arp, no brn)
  // output - dhcp packets (to wireless queue)
  elementclass DHCP {
  
    server :: DHCPServerLeases(10.9.0.1 , 10.9.0.0);
  
    input // check for dhcp
      //-> Print(Check_for_dhcp)
      -> EtherDecap()
      -> Align(4, 0)
      -> ip_check :: CheckIPHeader(CHECKSUM true)
      -> udp_check::CheckUDPHeader
      -> ipclass :: IPClassifier(icmp type echo-reply, -);
  
    ipclass[0]
      //-> Print("ICMP ECHO REPLY")
      -> [1]serverOffer :: DHCPServerOffer(server);
  
    ipclass[1]
      -> CheckDHCPMsg(request)
      -> class :: DHCPClassifier( discover, request, release, -);
  
    class[0]
      //-> Print(DISCOVER)
      -> [0]serverOffer;
  
    class[1]
      //-> Print(REQUEST)
      -> DHCPServerACKorNAK(server)
      -> UDPIPEncap( 10.9.0.1, 67, 255.255.255.255, 68 )
      -> EtherEncap( 0x0800, my_wlan, ff:ff:ff:ff:ff:ff)
      -> output;
  
    class[2]
      //-> Print(RELEASE)
      -> DHCPServerRelease(server);
  
    class[3]
      //-> Print(OTHER_drop)
      -> Discard;
  
    serverOffer[0]
      -> UDPIPEncap( 10.9.0.1, 67, 255.255.255.255, 68 )
      -> EtherEncap( 0x0800, my_wlan, ff:ff:ff:ff:ff:ff)
      -> output;
  
    serverOffer[1]
      -> icmpEncap::ICMPPingEncap(10.9.0.1, 255.255.255.255)
      -> DHCP_ICMP_Encap(serverOffer.dhcp_icmp_ping_src, serverOffer.dhcp_icmp_ping_dst)
      -> output;
  
    class[4] -> Discard();
    class[5] -> Discard();
    class[6] -> Discard();
    class[7] -> Discard();
    class[8] -> Discard();
  }
  
  
  out_q_0 :: Null(); //wifi_out_queue does the job
  
  // ----------------------------------------------------------------------------
  // Integration of DSR
  // ----------------------------------------------------------------------------
  
  AddressInfo(my_wlan ath0:eth);
  AddressInfo(my_vlan eth0:eth);
  //me :: NodeIdentity(my_wlan, my_vlan);
  nb_lst :: NeighborList(); // collect information about neighbors
  dsr :: DSR(ath0, eth0, eth0); // using DSR
  ds :: BRNDS(dsr/id, nb_lst);
  
  client_lst :: AssocList();
  client_ds :: ClientDS(ath0, eth0, vlan2, vlan0, client_lst);
  
  // ----------------------------------------------------------------------------
  // AP-Functionality
  // ----------------------------------------------------------------------------
  // TODO: BEACON_INTERVAL 100
  ap :: AccessPoint(DSR dsr, INTERFACE ath0, SSID ##brn2##, CHANNEL 1, BEACON_INTERVAL 100);
  
  // ----------------------------------------------------------------------------
  // Link Metric
  // ----------------------------------------------------------------------------
  
  //ett_metric :: BRNETTMetric(LT dsr/lt);
  etx_metric :: BRNETXMetric(LT dsr/lt);
  
  link_stat :: BRNLinkStat(ETHTYPE 0x0a04, 
          NODEIDENTITY dsr/id, 
          PERIOD 3000,
          TAU 30000,
          //PROBES "2 60 12 60 2 1400 4 1400 11 1400 22 1400 12 1400 18 1400 24 1400 36 1400 48 1400 72 1400 96 1400",
          //ETT ett_metric,
          ETX etx_metric,
          PROBES "22 1000",
          RT ap/rates);
  
  
  // ----------------------------------------------------------------------------
  // ARP-Table required for gateway functionality
  // ----------------------------------------------------------------------------
  arp :: ARPTable();
  
  // ----------------------------------------------------------------------------
  // Handling ath0-device
  // ----------------------------------------------------------------------------
  FromDevice(ath0) //, PROMISC true
    -> Prism2Decap()
    -> ExtraDecap()
    -> FilterPhyErr()
    -> filter :: FilterTX();
  
  filter[0]
    -> WifiDupeFilter()
    -> mgm_clf :: Classifier(0/00%0f, -); // management frames
  
  mgm_clf[0] //handle mgmt frames
    -> ap
    -> SetTXRate(22) // ap beacons send at constant bitrate
    -> wlan_out_queue :: NotifierQueue(50);
  
  mgm_clf[1] //handle other frames (data)
    -> WifiDecap()
    //-> rxstats :: RXStats()
    -> clf_bcast :: Classifier(0/ffffffffffff, -); // broadcast & unicast packets
  
    clf_bcast[0]
  //  -> ToDump(from.dat, ENCAP ETHER)
    -> arp_clf :: Classifier (12/0806, 12/8086, -);
  
  
  // ----------------------------------------------------------------------------
  // Handling DHCP queries
  // ----------------------------------------------------------------------------
  //TODO
  dhcp :: DHCP();
  arp_clf[2] // check for dhcp
  //-> Discard;
  //Idle()
    -> dhcp
    -> WifiEncap(0x02, WIRELESS_INFO ap/winfo) //to station
    -> SetTXRate(22) // currently bitrate with clients no adopted
    -> wlan_out_queue;
  
  clf_bcast[1]
    -> protoclf :: Classifier(12/8086, //brn-protocoll
                            -);
  arp_clf[0] -> Discard;
  
  arp_clf[1] // brn broadcasts
    -> protoclf;
  
  protoclf[1] //simple packets (no brn)
    //-> PrintWifi(from_dev)
    -> Classifier(12/0800) // ip packet
    -> host_cl :: IPClassifier(dst net 10.9.1.1 mask 255.255.255.0,
          -);
  
  host_cl[0] // for other brn clients or internal nodes
    -> [0]dsr;
  
  
  //AddressInfo(gw 00:0F:B5:3F:21:60);
  //AddressInfo(gw 00:0F:B5:3F:1B:BF);
  //AddressInfo(gw 00:0F:B5:3F:1E:EA);
  //AddressInfo(gw 00:0F:B5:3F:20:D6);
  
  host_cl[1] // packet for the outside world
    //-> Print(set_brn_gw)
    //-> BRNGateway(gw) // prefered gw
    -> [0]dsr;
  
  protoclf[0] //brn packets
    //-> Print(brn, 128)
    -> EtherDecap()
    -> nb_lst //know your neighbor
    -> brnclf :: Classifier(0/01, //BrnSDP
                            0/02, //BrnTFTP
                            0/03, //BrnDSR
                            0/04, //BrnBcast
                            0/06, //LinkProbe
                            -        //other
                            );
  
  brnclf[0] // sdp 
  -> Discard;
  
  brnclf[1] // tftp
  -> Discard;
  
  brnclf[2] //dsr
    -> [1]dsr;
  
  brnclf[3] //bcast
    -> Discard;
  
  brnclf[4] //linkprobe
    //-> Print(linkprobe)
    -> link_stat
    -> SetTimestamp()
    -> EtherEncap(0x8086, my_wlan, ff:ff:ff:ff:ff:ff)
    //-> Print(link_probe_to_dev)
    -> WifiEncap(0x00, 0:0:0:0:0:0) // packet to brn peer node
    -> wlan_out_queue;
  
  brnclf[5] //other
    -> Discard;
  
  //Idle()
  //-> [1]udt
  
  dsr[0] //for an assoc client
    //-> Print(from_dsr0)
    -> dst_clf :: DstClassifier(dsr/id, client_lst);
  
  //udt[0]
  //  -> Print(UDT_0)
  //  -> dst_clf;
  
  dst_clf[1] // for assoc client
    //-> Print(packet_assoc_client_raw)
    -> client_ds;
  
  client_ds[0]
    //-> Print(wireless_client)
    -> WifiEncap(0x02, WIRELESS_INFO ap/winfo) //to station
    -> SetTXRate(22) // no bitrate selection to client nodes!
    -> wlan_out_queue;
  
  client_ds[1]
    -> dev_eth0_q :: Queue
    -> dev_eth0 :: ToDevice(eth0); //eth0
  
  client_ds[2]
    -> Discard; //vlan2
  
  client_ds[3]
    -> Discard; //vlan0 (debug)
  
  dst_clf[0]
    //-> Print(packet_for_me)
    -> Classifier(12/0800) // ip packet
    -> CheckIPHeader(14)
    //-> IPPrint(xxx)
    -> tohost_cl :: IPClassifier(dst net 10.9.1.1 mask 255.255.255.0,
          -);
  
  dst_clf[2]
    //-> Print(Unknown)
    -> Discard;
  
  tohost_cl[0]
    //-> Print(to_ping)
    -> EtherDecap()
    -> CheckIPHeader
    -> ICMPPingResponder
    -> BRNEtherEncap
    //-> Print(ping_resp)
    -> [0]dsr; // back on route
  
  tohost_cl[1] // for the tun device
    //-> Print(ToHost)
  //  -> IPPrint(ToHost)
  //  -> ToHost(ath0);
    -> SetEtherAnno()
    -> MarkIPHeader(14)
    -> rewriter2 :: EtherIpAddrRewriter(ACTIVE false)
    //-> IPPrint(before) -> Print(before)
    -> dev_eth0_q;
  
  
  //  -> Print(to_tun)
  //  -> Strip(14)
  //  -> MarkIPHeader(0)
    //-> StoreIPEthernet(arp) // store ip mac combination
    //-> EtherDecap()
  //  -> CheckIPHeader(0)
  //  -> IPPrint(to_fake)
    // replace the real destination address with the fake address
  //  -> StoreIPAddress(192.168.3.22, 12) //src
  //  -> SetPacketType(HOST) 
  //  -> SetIPChecksum
  //  -> IPPrint(to_fake2)
  //  -> EtherEncap(0x0800, my_vlan, my_vlan)
  //  -> Print(to_fake2)
  //  -> ToHost(eth0);
  
  
  dsr[1] //for an other internal node; make use of ds
    //-> Print(from_dsr1)
    -> ds;
  ds[0] -> out_q_0;
  ds[1] -> Discard;
  ds[2] -> Discard;
  
  out_q_0
    -> WifiEncap(0x00, 0:0:0:0:0:0) // sollte das WDS Packet erzeugen mit Hilfe eines Parameters
    -> wlan_out_queue
    -> SetTXRate(22)
    -> SetTXPower(63)
    //-> PrintWifi(to_wlan)
    //-> ToDump(todev_node5, ENCAP 802_11)
    -> ExtraEncap()
    -> ToDevice(ath0);
  
  
  filter[1] //take a closer look at tx-annotated packets
    -> failures :: FilterFailures();
  
  failures[0]
    -> Discard;
  
  failures[1]
    -> WifiDupeFilter()
    -> mgm_clf2 :: Classifier(0/00%0f, -); // management frames
  
  mgm_clf2[0] //handle mgmt frames
    -> Discard;
  
  mgm_clf2[1] //other frames
    //-> PrintWifi(failure)
    -> WifiDecap()
    -> Classifier(12/8086) //handle only brn protocol
    //-> Print(failure)
    -> EtherDecap()
    -> [2]dsr;
  
  
  // ------------------------------------------------
  // Test Area
  // ------------------------------------------------
  
  AddressInfo(peer_client 00:11:11:3E:B8:79);
  
  FromDevice(eth0) // debug queue
    -> _tst_clf1 :: Classifier(12/0800,-) // ip packet
    -> MarkIPHeader(14)
    -> _tst_clf2 :: IPClassifier(port ##port##, -)
    //-> IPPrint(from_vlan0, TIMESTAMP true)
    //-> Print(from_vlan0)
    -> SetEtherAnno()
    -> rewriter1 :: EtherIpAddrRewriter()
    //-> IPPrint(rewritten, TIMESTAMP true)
    //-> Print(rewritten)
    -> host_cl;
  
  _tst_clf1[1] -> ToHost(eth0);
  _tst_clf2[1] -> ToHost(eth0);
  
  ch :: CompoundHandler( debug, "ds dsr/id dsr/lt dsr/dsr_encap
    dsr/brn_encap dsr/dsr_decap client_lst  nb_lst dsr/querier 
    dsr/req_forwarder dsr/rep_forwarder dsr/src_forwarder dsr/err_forwarder", false );
  
  poki :: PokeHandlers(//write client_lst.insert 00:0e:35:a2:e4:31 ath0, //associate client with node1
  //            write madwifi_rate.debug true,
  //            write dhcp/server.dhcpd_conf 
  //            subnet 10.9.1.0 netmask 255.255.255.0{
  //              option routers 10.9.1.1
  //              option subnet-mask 255.255.255.0
  //              option domain-name brn
  //              option domain-name-servers 141.20.20.50
  //              range dynamic-bootp 10.9.1.2 10.9.1.30
  //              default-lease-time 3000
  //              max-lease-time 6000
  //            },
              wait 1,
  //            read dhcp/server.read_free_leases,
  //            write dsr/querier.fixed_route
  //              00:0f:b5:3f:21:60
  //              00:0f:b5:3f:20:d6
  //              00:0f:b5:3f:1e:ea
  //              00:0f:b5:0b:95:29
  //              00:0f:b5:3f:1b:bf
  //              00:0e:35:a2:e4:31
              );