src/net/ip.old.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/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/net/net.hpp"
#include "src/net/arp.hpp"
#include "src/net/ip.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/thread/timer.hpp"
#include "src/collection/option.hpp"
#include "src/collection/avlmap.hpp"
#include "src/collection/list.hpp"
#include "src/collection/tuple.hpp"

   #define DUMP_IP_PACKET_INFO 1

namespace Net {
   namespace IP { 

      struct ip_address my_ip_address() {
         return ip_address(0x03000006);
      }

      struct netmask_t my_netmask() {
         return netmask_t(0xffffff00);
      }

      using namespace Collection;
      
      int ip_outbound_cmp(struct Tuple2<struct ip_address, struct netbuf* > a, struct Tuple2<struct ip_address, struct netbuf*> b) {
         if (a._1.ip > b._1.ip)
            return 1;
         if (a._1.ip < b._1.ip)
            return -1;

         return pointer_cmp<struct netbuf> (a._2, b._2);
      }

      struct AvlTree<struct Tuple2<struct ip_address, struct netbuf*>, ip_outbound_cmp> *ip_outbound;
      struct IPC::Lock::lock_t ip_outbound_lock(const_cast<char*>("ip_outbound"));

      void init() {
         ip_outbound= new AvlTree<struct Tuple2<struct ip_address, struct netbuf*>, ip_outbound_cmp>();
      }


      void ip_onNewArpEntry(struct Net::Arp::arp_entry arp) {
         ip_outbound_lock.lock();
         struct Option<struct Tuple2<struct ip_address,struct netbuf*> > opt;
         struct Tuple2<struct ip_address, struct netbuf*> templ = Tuple2<struct ip_address, struct netbuf*>(arp.ip_addr, null);


         println(opt);
         while ( (opt = ip_outbound->find(templ)).isNone() == false) {
            struct Tuple2<struct ip_address, struct netbuf*> v= opt.get();
            ip_outbound->remove(v);
            println(v); 
         }
         ip_outbound_lock.ulock();
      }

      void ip_transmit(struct netif *nif, struct ip_address ip_addr, uint8 tos, uint8 prot, struct pbuf *pb) {
         assert(sizeof(struct ip_header)==20);
         testif(pb);
         if (pb->ip_data_off < sizeof(struct ip_header)) {
            complain("no space for ip header in packet buffer");
            return ;
         }
         struct ip_header *ip;
         pb->ip_off=pb->ip_data_off - sizeof(struct ip_header);
         ip=reinterpret_cast<struct ip_header*>(&pb->data[pb->ip_off]);
         ip->version=4;
         ip->hdr_len=sizeof(struct ip_header)/sizeof(uint32);
         ip->tos=tos;
         ip->len=htons(pb->end  -  pb->ip_off);
         static uint16 ip_iden=0;
         ip->iden= htons(ip_iden++);
         ip->flags=0;
         ip->offset=htons(0);
         ip->ttl=32;
         ip->prot=prot;
         ip->checksum=0;
         ip->source_ip=nif->ip_addr;
         ip->target_ip=ip_addr;

         ip->checksum= count_checksum16(reinterpret_cast<uint16*>(ip), sizeof(struct ip_header)/sizeof(uint16));
         struct Option<struct ethernet_address> eth_addr =  Net::Arp::arp_get_ether(ip_addr);
         if (eth_addr.isNone()) {
            ip_outbound_lock.lock();
            Thread::Timer::avltree_insert_with_timer(DEF_SECOND*30,
                                                      ip_outbound,
                                                      Tuple2<struct ip_address, struct netbuf*>(
                                                                ip_addr, 
                                                                new netbuf(pb->end - pb->ip_off, &pb->data[pb->ip_off], null, nif)
                                                                )
                                                    );
            ip_outbound_lock.ulock();
         } else {
            eth_transmit(nif, eth_addr.get(), 0x0800, new netbuf(pb->end-pb->ip_off, &pb->data[pb->ip_off], null, nif));
         }
      }
   }
}

---