src/net/arp.cpp

Idź do dokumentacji tego pliku.

/*{{{
 panaLiX, Adrian Panasiuk 2002-5,8
 http://panalix.sourceforge.net/
 ad.ek336@gmail.com
 
 small osdev project
 provided under GPLv3 license.
 */

#include "src/common/shared.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/collection/avltree.hpp"
#include "src/collection/option.hpp"
#include "src/ipc/lock.hpp"
#include "src/common/prng.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/thread/timer.hpp"
#include "src/net/arp.hpp"
#include "src/net/ip.hpp"
#include "src/net/3c556.hpp"/*}}}*/


#define ARP_REBOOT_PACKET 1
//3.0.0.14; takze wystepuje w Makefile
#define ARP_REBOOT_DESTINATION 0x0300000E
#define ARP_FREEZE_DESTINATION 0x0300000F


namespace Net {
   namespace Arp {
   
   struct Memory::Heap::heapbox arp_heapbox;


      struct arp_ethernet_packet {/*{{{*/
         short hw_type;
         short prot_type;
         char hw_size;
         char prot_size;
         short opcode;
         struct ethernet_address sender_eth;
         struct ip_address sender_ip;
         struct ethernet_address target_eth;
         struct ip_address target_ip;
      } __attribute__ ((packed));/*}}}*/

      void arp_transmit(struct netif *nif,/*{{{*/
                        short opcode,
                        struct ethernet_addr packet_destination,
                        struct ethernet_addr sender_eth, struct ip_address sender_ip,
                        struct ethernet_address target_eth, struct ip_address target_ip);/*}}}*/

      void arp_transmit(struct netif *nif, short opcode, struct ethernet_address destination_eth, struct ethernet_address target_eth, struct ip_address target_ip) {
         struct netbuf *nb;
         nb = netbuf_alloc(sizeof(struct arp_ethernet_packet));
      #if 0/*{{{*/
         dbPrintInt((uint32)nb->data);
         dbSetRow(0);
      #endif/*}}}*/
         struct arp_ethernet_packet *arp = reinterpret_cast<struct arp_ethernet_packet*>(nb->data);
         arp->hw_type=htons(0x0001);
         arp->prot_type=htons(0x0800);
         arp->hw_size=6;
         arp->prot_size=4;
         arp->opcode=htons(opcode);
         arp->sender_eth=nif->eth_addr;
         arp->sender_ip=nif->ip_addr;
         arp->target_eth=target_eth;
         arp->target_ip=target_ip;
         testifdbg( nb->len != 0); 
         eth_transmit(nif, destination_eth, 0x0806, nb);
      }/*}}}*/

      void arp_transmit_request(struct netif *nif, struct ethernet_address destination_eth, struct ip_address target_ip) {/*{{{*/
         arp_transmit(nif, 0x0001, destination_eth, ethernet_address(0,0,0,0,0,0), target_ip);
      #if 0/*{{{*/
         struct netbuf *nb;
         nb = netbuf_alloc(sizeof(struct arp_ethernet_packet));
         struct arp_ethernet_packet *arp = reinterpret_cast<struct arp_ethernet_packet*>(nb->data);
         arp->hw_type=htons(0x0001);
         arp->prot_type=htons(0x0800);
         arp->hw_size=6;
         arp->prot_size=4;
         arp->opcode=htons(0x0001);
         arp->sender_eth=nif->eth_addr;
         arp->sender_ip=nif->ip_addr;
         arp->target_eth=ethernet_address(0,0,0,0,0,0);
         arp->target_ip=ip_addr;
         eth_transmit(nif, ethernet_address(0xFF,0xFF,0xFF,0xFF,0xFF,0xFF), 0x0806, nb);
      #endif/*}}}*/
      }/*}}}*/
      
      void arp_transmit_reply(struct netif *nif, struct ethernet_address target_eth, struct ip_address target_ip) {/*{{{*/
         arp_transmit(nif, 0x0002, target_eth, target_eth, target_ip);
      }/*}}}*/

#if 0/*{{{*/
      struct arp_entry {
         struct netif *nif;
         struct Collection::Option<struct ethernet_address> eth_addr;
         struct ip_address ip_addr;
         uint64 expire;
         uint64 retry;  //for incomplete entries, the retry moment
         uint32 retries;
      };

      int inline arp_entry_cmp(struct arp_entry a, struct arp_entry b) {
         return Collection::generic_cmp<uint64>(a.retry, b.retry);
      }

      struct Collection::AvlTree<struct arp_entry, arp_entry_cmp> *arp_cache;
      class IPC::Lock::lock_t arp_cache_lock(const_cast<char*>("arp cache"));

      void arp_cache_insert(struct netif *nif, struct ip_address ip, struct ethernet_address eth) {
         arp_cache_lock.lock();
         struct arp_entry arp;
         arp.nif = nif;
         arp.eth_addr = Collection::Option<struct ethernet_address>(eth);
         arp.ip_addr = ip;
         arp.retry = arp.expire = Arch::x86::RTC::up_time + DEF_SECOND*3;   //niech bedzie 5 minut
         arp.retries=0;
         arp_cache->insert(arp);

         lnDbg;

         arp_cache_lock.ulock();
      }

      //co pewien czas wyslij ponowne zapytanie arp dla niektorych adresow ip a niektore wpisy arp odrzuc
      int arpTimer(int a, int b) {
         arp_cache_lock.lock();
         struct arp_entry arp;
         struct Collection::Option<struct arp_entry> arp_opt;
         uint64 time = Arch::x86::RTC::up_time;

         struct Collection::AvlTree<struct arp_entry, arp_entry_cmp> arp_pom;

         for (arp_opt = arp_cache->findMin();
                                      !arp_opt.isNone() && arp_opt.get().retry <= time;
                                       arp_opt = arp_cache->findMin()) {
            arp = arp_opt.get();
            arp_cache->remove(arp);
            if (arp.expire > time)
               arp_pom.insert(arp);
         }

         //w arp_pom mamy teraz wszystkie niekompletne arp entries
         for (arp_opt = arp_pom.findMin();
                                 !arp_opt.isNone();
                                 arp_opt = arp_pom.findMin()) {
            arp = arp_opt.get();
            arp_pom.remove(arp);
            arp_transmit_request(arp.nif, ethernet_address(0xff,0xff,0xff,0xff,0xff,0xff), arp.ip_addr);
            if (arp.retries == 1)
               arp.retry += PRNG::nextUint32(200);      //200/1024 sekundy
            if (arp.retries == 2)
               arp.retry += PRNG::nextUint32(1024);     //sekunda
            if (arp.retries == 3)
               arp.retry += PRNG::nextUint32(1024*5);     //5 sek
            if (arp.retries >= 4)
               arp.retry += PRNG::nextUint32(1024*arp.retries*5);
            if (arp.retry < arp.expire)
               arp_cache->insert(arp);
            arp.retries ++;
         }

         arp_cache_lock.ulock();
         
         return 1;
      }
#endif/*}}}*/


      using namespace Collection;

      int arp_entry_cmp(struct arp_entry a, struct arp_entry b) {/*{{{*/
         return generic_cmp<uint32>(a.ip_addr.ip, b.ip_addr.ip);
      }/*}}}*/

      struct AvlTree<struct arp_entry,arp_entry_cmp> *arp_cache;
      struct IPC::Lock::lock_t arp_cache_lock(const_cast<char*>("arp_cache"));

      void arp_cache_insert(struct netif *nif, struct ip_address ip_addr, struct ethernet_address eth_addr) {
         arp_cache_lock.lock();
         struct arp_entry arp;
         arp.ip_addr=ip_addr;
         if (arp_cache->find(arp).isNone()==false) {
                  arp_cache_lock.ulock();
                  return ;
         }

         assert(arp.ip_addr.ip == ip_addr.ip);
         arp.nif=nif;
         arp.eth_addr=eth_addr;
  //       arp.expire = Arch::x86::RTC::up_time + DEF_SECOND * 3;  //nominalnie 5 minut
        // arp_cache->insert(arp);
//         Thread::Timer::avltree_insert_with_timer( 60*DEF_SECOND, arp_cache, arp );
         arp_cache->insert(arp);
//         arp_cache->write();
         arp_cache_lock.ulock();
uint32 fl;
ENTER_CRITICAL(fl);
#if 0/*{{{*/
                     do {
                        struct arp_entry a;
                        a.eth_addr.d[0]=0x22;
                        a.ip_addr=0x03000001;//ip_addr;//0x03000001;
                        struct ethernet_address e= arp_get_cached_ether(a.ip_addr).get();
                        e = arp_cache->find(a).get().eth_addr;
//                        e = arp.eth_addr;
                        for (int i=0;i<6;i++)
                           kprintf("%x:",e.d[i]);
                        kprintf("\n");
                        arp_cache->write();
                     } while(0);
                     for(;;);
#endif/*}}}*/
         Net::IP::ip_onNewArpEntry(arp);
      }

      struct Option<struct ethernet_address> arp_get_cached_ether(struct ip_address ip) {
         struct arp_entry arp;
         arp.ip_addr=ip;
         struct Option<struct arp_entry> opt = arp_cache->find(arp);
         if (opt.isNone())
            return Option<struct ethernet_address>();
         return Option<struct ethernet_address>(opt.get().eth_addr);
      }
      
      int arp_request_timer(struct arp_entry *arp, int T) {
         if (arp_get_cached_ether(arp->ip_addr).isNone() == false) {    //juz otrzymalismy adres ethernetowy
            arp_heapbox.free(arp);
            return 0;
         }
         //jeszcze nie otrzymalismy adresu ethernetowego
         if (T > 2*2*2*2*2*2*100)
            return 0;

         arp_transmit_request(arp->nif, ethernet_address(0xff,0xff,0xff,0xff,0xff,0xff), arp->ip_addr );
         Thread::Timer::add(reinterpret_cast<int(*)(int,int)>(arp_request_timer), T/2+T+PRNG::nextUint32(T/2), reinterpret_cast<uint32>(arp), T/2+T+PRNG::nextUint32(T/2) );
         //Thread::Timer::add(reinterpret_cast<int(*)(int,int)>(arp_request_timer), PRNG::nextUint32(T), reinterpret_cast<uint32>(arp), PRNG::nextUint32(T) );

         return 0;
      }

      struct Option<struct ethernet_address> arp_get_ether(struct ip_address ip) {
         struct Option<struct ethernet_address> opt;
         opt = arp_get_cached_ether(ip);
         if (opt.isNone() == false)
            return opt;
         struct arp_entry *arp = static_cast<struct arp_entry*>(arp_heapbox.malloc(sizeof(struct arp_entry),1,"arp entry",null));
         arp->ip_addr= ip;
         arp->nif=e3c556_nif;
         Thread::Timer::add(reinterpret_cast<int(*)(int,int)>(arp_request_timer), 1, reinterpret_cast<uint32>(arp), 100);
         return Option<struct ethernet_address>();
      }
#if 0
      int arpTimer(int a, int b) {
         return 0;
      }
#endif


      void init() {/*{{{*/
         allocate_heapbox(&arp_heapbox, "arp");
         arp_cache = new AvlTree<struct arp_entry, arp_entry_cmp>;
      }/*}}}*/

      using namespace Collection;

      struct AvlTree<uint32,generic_cmp<uint32> > *arp_pom;

      void processArpPacket(struct netbuf *nb) {
         struct arp_ethernet_packet *arp;
            arp = reinterpret_cast<struct arp_ethernet_packet*>(&nb->data[14]);

         //IPoE, ARP protocol
            if (arp->hw_type==htons(0x0001) && arp->prot_type==htons(0x0800) && arp->hw_size==6 && arp->prot_size==4) {
      #if ARP_REBOOT_PACKET
            //specjalny IP
                     if (arp->target_ip.ip == ip_address(ARP_REBOOT_DESTINATION).ip) {
                        complain("special ARP packet forces to reboot");
                        reboot();
                     }
                     if (arp->target_ip.ip == ip_address(ARP_FREEZE_DESTINATION).ip) {
                        complain("special ARP packet forces to freeze");
                        asm volatile("cli\nhlt");
                     }
      
      #endif
               //nasz IP
                  if (arp->target_ip.ip==nb->nif->ip_addr.ip) {
                  if (arp->opcode == htons(0x0001)) {
                        //dostalismy arp request
                        if (arp_pom == null)
                           arp_pom = new Collection::AvlTree<uint32, generic_cmp<uint32> >;
                        //jak dostajemy mnostwo arp request z jednego miejsca to zebysmy nie wysylali duzo arp reply
                        if (arp_pom->find(arp->sender_ip.ip).isNone()) {   // jesli true, to znaczy ze nie wysylalismy od jakiegos czasu arp request na ten ip
                           arp_transmit_reply(nb->nif, arp->sender_eth, arp->sender_ip);
                           Thread::Timer::avltree_insert_with_timer(200, arp_pom, arp->sender_ip.ip); //ignore arp requests from this ip for some time
                           /* we can store the ip -> eth mapping now from the arp request we received */
                           arp_cache_insert(nb->nif, arp->sender_ip, arp->sender_eth);
                        }
                  } else if (arp->opcode == htons(0x0002)) {
                        //dostalismy arp reply
                        arp_cache_insert(nb->nif, arp->sender_ip, arp->sender_eth);
                  }
               }
            }


            netbuf_free(nb);
      }

      struct Collection::Option<struct ethernet_address> arp_get_cached_ether(struct ip_address ip);
      struct Collection::Option<struct ethernet_address> arp_get_ether(struct ip_address ip);

   }
}

---