www.pudn.com > e041tcpipc51.rar > ip.c

#include  
#include  
#include "ethernet.h" 
#include "ip.h" 
#define IP_TTL          128     /* Time To Live for an outgoing IP datagram */ 
extern  NODE locnode;       //本机的节点信息结构(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)); 
} 
*/