src/net/ip.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/collection/tuple.hpp"
#include "src/collection/option.hpp"
#include "src/net/arp.hpp"
#include "src/net/ip.hpp"
#include "src/net/icmp.hpp"
#include "src/net/3c556.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/thread/timer.hpp"
#include "src/collection/avlmap.hpp"
#include "src/collection/list.hpp"

   #define DUMP_IP_PACKET_INFO 1
   #define DEBUG_IP_CHECKSUM_ALERT 0
   #define DEBUG_IP_FRAGMENTED_ALERT 0
   #define DEBUG_IP_PROT_ALERT 0

/* adipelix */
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;

      void onIpReception(struct netbuf *nb) {
         //println(*nb);
         struct ip_header *iph;
         iph= reinterpret_cast<struct ip_header*>(&nb->data[14]);
         if (count_checksum_iph(iph) != iph->checksum) {
         #if DEBUG_IP_CHECKSUM_ALERT
            println(*nb);
            println(*iph);
            complain("incorrect checksum: datagram dropped");
         #endif
         } else {
            if ((iph->flags_fo & 2) || ((0x1FFF&ntohs(iph->flags_fo)) != 0)) {
            #if DEBUG_IP_FRAGMENTED_ALERT
               println(*nb);
               println(*iph);
               complain("fragmented datagram dropped");
            #endif
            } else {
                 switch (iph->prot) {
                  case 0x01 : Net::ICMP::processDatagram(nb);
                              break;
                  default:
                  #if DEBUG_IP_PROT_ALERT
                     print(*nb);
                     print(*iph);
                     complain("protocol unavaillable");
                  #endif

                     break;
                 }
            }
         }
         netbuf_free(nb);
      }
      
      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);
      }

      int ip_outbound_cmp_by_first(struct Tuple2<struct ip_address, struct netbuf* > a, struct Tuple2<struct ip_address, struct netbuf*> b) {
         return generic_cmp<uint32>(a._1.ip, b._1.ip);
      }

      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);

         while ( (opt = ip_outbound->findcmp< ip_outbound_cmp_by_first >(templ)).isNone() == false) {
            struct Tuple2<struct ip_address, struct netbuf*> v= opt.get();
            struct netbuf *nb = v._2;
            ip_outbound->remove(v);
            eth_transmit(nb->nif, arp.eth_addr, 0x0800, nb);
         }
         ip_outbound_lock.ulock();
      }

      uint16 count_checksum_iph(struct ip_header *iph) {
         uint16 sv= iph->checksum;
         iph->checksum=0;
         uint16 ret= count_checksum16(reinterpret_cast<uint16*>(iph), sizeof(struct ip_header));
         iph->checksum=sv;
         return ret;
      }

      void ip_transmit(struct ip_address ip_addr, uint8 tos, uint8 prot, struct packet_t *pb) {
         struct pbuf *p;
         p = reinterpret_cast<struct pbuf*>(kmalloc(sizeof(struct pbuf),"pbuf"));
         p->data=pb->buf;
         p->ip_data_off=pb->off;
         p->len=pb->capacity;
         p->end=pb->end;
         ip_transmit(ip_addr,tos,prot,p);
      }

      void ip_transmit(struct ip_address ip_addr, uint8 tos, uint8 prot, struct pbuf *pb) {
         struct netif *nif = e3c556_nif;
         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_fo=htons(0);
         ip->ttl=32;
         ip->prot=prot;
         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));
         ip->checksum= count_checksum_iph(ip);
         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));
         }
      }
   }
}

void print (struct Net::IP::ip_header iph) {
   char ltrs[] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
   prin("(IPv");
   putch(ltrs[iph.version]);
   prin(": hdrlen=", iph.hdr_len, " tos=", iph.tos, " len=", Net::ntohs(iph.len), " iden=", Net::ntohs(iph.iden),
            " flags_fo=", Net::ntohs(iph.flags_fo), " ttl=", iph.ttl, " prot=", iph.prot, " chsum=", Net::ntohs(iph.checksum));
   uint16 v= Net::IP::count_checksum_iph(&iph);
   if (v==iph.checksum)
      prin("(correct)");
   else
      prin("(should be ", Net::htons(v), ")");
   prin(" src=", iph.source_ip, ", target=", iph.target_ip, ")");
}

void print (struct Net::IP::pbuf pb) {
   notimpl();
}

void print (struct Net::IP::route_t &route) {
   prin("(route_t: target=", route.target, " netmask=", route.netmask, " gateway=", route.gateway, " nif= ", (route.nif==null?"null":route.nif->name), " flags=",route.flags,")");

}

---