#include <stdio.h>
#include <string.h>
#include "ethernet.h"
#include "ip.h"
#define IP_TTL          128     /* Time To Live for an outgoing IP datagram */
extern  NODE locnode;       //本機(jī)的節(jié)點(diǎn)信息結(jié)構(gòu)(mac,ip,mask,port)
/* Check ARP packet, swap bytes, return -1, 0 if not ARP */
int is_arp(ETHERFRAME *efp, int len)
{
    ARPKT *arp;
    int dlen=0;
    if (efp->e.ptype==PCOL_ARP && len>=sizeof(ARPKT))
    {                                   	/* If protocol OK.. */
        arp = (ARPKT *)(efp->edata);
        if (arp->hrd==HTYPE && arp->pro==ARPPRO)
            dlen = -1;                  	/* Return non-zero if OK */
        else
            dlen = 0;    
    }
    return(dlen);
}
/* Make an ARP packet, return its total length */
int make_arp(ETHERFRAME *efp, NODE *srcep, NODE *destp, WORD codetype)
{
    ARPKT *arp;
    arp = (ARPKT *)(efp->edata);
    memcpy(arp->smac, srcep->mac, MACLEN);  	/* Srce ARP ether addr */
    memcpy(arp->dmac, destp->mac, MACLEN);  	/* Dest ARP ether addr */
    arp->hrd = HTYPE;                   		/* Hware & protocol types */
    arp->pro = ARPPRO;
    arp->hln = MACLEN;                  	/* Hardware addr len */
    arp->pln = sizeof(LWORD);          		/* IP addr len */
    arp->op  = codetype;                    /* ARP opcode */
    arp->dip = gate_ip(destp, srcep);   	/* Dest ip addr (maybe gateway) */
    arp->sip = srcep->ip;               	/* Source IP addr */
    return(make_frame(efp,srcep->mac,destp->mac, PCOL_ARP, sizeof(ARPKT)));
}

/* Check frame is IP, checksum & byte-swap, return data len */
int is_ip(ETHERFRAME *efp, int len)
{
    int ver, dlen=0, hlen;
    WORD sum;
    IPKT *ip;
    if (efp->e.ptype==PCOL_IP && len>=sizeof(IPHDR))
    {
        ip = (IPKT *)(efp->edata);           /* Get pointer to IP frame */
        ver = ip->i.vhl >> 4;                /* Get IP version & hdr len */
        hlen = (ip->i.vhl & 0xf) << 2;
        sum = ~csum(&ip->i, (WORD)hlen);     /* Do checksum */
        if (ver==4 && len>=hlen && sum==0)   /* If OK.. */
        {
            dlen = min(ip->i.len,len);
            dlen-=hlen;
            if (hlen > sizeof(IPHDR))        /* If IP options present.. */
            {                                /* ..delete them, move data down */
                memmove(ip->ipdata, &ip->ipdata[hlen-sizeof(IPHDR)], len);
                dlen -= hlen-sizeof(IPHDR);
            }
        }
    }
    return(dlen);
}

/* Make an IP packet, if greater than the MTU, also make fragment (subframe) in
** this frame. Return total length of frame and subframes (if any) */
int make_ip(ETHERFRAME *efp, NODE *srcep, NODE *destp, BYTE pcol, WORD dlen)
{
    IPKT *ip;
    static WORD ident=1;
    ip = (IPKT *)(efp->edata);           	/* Get pointer to IP datagram */
    ip->i.ident = ident;               	 	/* Set datagram ident */
    ip->i.frags = 0;           		 		/* Frag offset in units of 8 bytes */
    ip->i.vhl = 0x40+(sizeof(IPHDR)>>2);	/* Version 4, header len 5 LWORDs */
    ip->i.service = 0;                  	/* Routine message */
    ip->i.ttl = IP_TTL;                 	/* Time To Live */
    ip->i.pcol = pcol;                  	/* Set IP protocol */
    ip->i.sip = srcep->ip;              	/* Srce, dest IP addrs */
    ip->i.dip = destp->ip;
    ip->i.len = dlen + sizeof(IPHDR);    	/* Data length */
    ip->i.check = 0;                    	/* Clear checksum */
    ip->i.check = ~csum(ip, sizeof(IPHDR)); /* ..then set to calc value */
    ident++;                            	/* Increment datagram ident */
    return(make_frame(efp, srcep->mac,destp->mac, PCOL_IP, (WORD)dlen+sizeof(IPHDR)));
}

/* Get the frame driver type, source IP and Ethernet addresses
** Returned data does not include port number, netmask or gateway addr */
void getip_srce(ETHERFRAME *efp, NODE *np)
{
    IPHDR *iph;
    memcpy(np->mac,efp->e.srce,6);
    iph = (IPHDR *)(efp->edata);
    np->ip = iph->sip;
}
/* Get local node data corresponding to a frame destination IP address
** Data does not include port number. Return 0 if no matching local node */
int getip_locdest(ETHERFRAME *efp,NODE *np)
{
    IPHDR *iph;
    int ok=0;

    iph =(IPHDR *)(efp->edata);
    if (iph->dip==locnode.ip)
    {   
    	*np=locnode;
    	ok=1;
    }
    return (ok);
}

/* Check a remote address to see if it is on the local subnet.
** If so (or no gateway), return it. If not, return the gateway IP address */
LWORD gate_ip(NODE *remp, NODE *locp)
{
    return((locp->gate==0||on_subnet(remp->ip, locp)) ? remp->ip : locp->gate);
}

/* Check an IP address to see if it is on a subnet, return 0 if not */
int on_subnet(LWORD remip, NODE *locp)
{
    return(((remip ^ locp->ip) & locp->mask) == 0);
}


/* Return ICMP data length (-1 if no data), 0 if not ICMP */
int is_icmp(IPKT *ip, int len)
{
    ICMPKT *icmp;
    WORD sum;
    int dlen=0;

    if (ip->i.pcol==PICMP && len>=sizeof(ICMPHDR))
    {
        icmp = (ICMPKT *)ip;
        if ((sum=csum(&icmp->c, (WORD)len)) == 0xffff)
            dlen = len>sizeof(ICMPHDR) ? len-sizeof(ICMPHDR) : -1;
//        else
//            printf("\r\nICMP checksum error: %04X\r\n", sum);
    }
    return(dlen);
}

/* Make an ICMP packet */
int make_icmp(ETHERFRAME *efp, NODE *srcep, NODE *destp, BYTE type, BYTE codetype,WORD dlen)
{
    ICMPKT *icmp;
    WORD len;
    icmp = (ICMPKT *)(efp->edata);
    icmp->c.type = type;
    icmp->c.codetype = codetype;
    icmp->c.check = 0;
    len = (WORD)(dlen + sizeof(ICMPHDR));
    icmp->c.check = ~csum(&icmp->c, len);
    return(make_ip(efp, srcep, destp, PICMP, len));
}

/* Make ICMP 'destination unreachable' for incoming frame */

/*
int icmp_unreach(ETHERFRAME *efp, NODE *srcep, NODE *destp, BYTE codetype)
{
    int len;
    ICMPKT *icmp;
    icmp = (ICMPKT *)(efp->edata);
    len = ((icmp->i.vhl & 0xf) << 2) + 8;
    memmove(icmp->icmpdata, icmp, len);
    return(make_icmp(efp, srcep, destp, ICUNREACH, codetype, (WORD)len));
}
*/