ip.c.bak

一个比较好的三星s3c4510的启动代码

    np->dtype = gfp->g.dtype;
    getframe_srce(gfp, np->mac);
    iph = getframe_datap(gfp);
    np->ip = iph->sip;
}

/* Get the frame driver type, destination IP and Ethernet addresses
** Returned data does not include port number, netmask or gateway addr */
void getip_dest(GENFRAME *gfp, NODE *np)
{
    IPHDR *iph;

    np->dtype = gfp->g.dtype;
    getframe_dest(gfp, np->mac);
    iph = getframe_datap(gfp);
    np->ip = iph->dip;
}

/* 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(GENFRAME *gfp, NODE *np)
{
    IPHDR *iph;
    NODE *locp;
    int ok=0;

    iph = getframe_datap(gfp);
    ok = (locp = findloc_ip(iph->dip)) != 0;
    if (ok)
        *np = *locp;
    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)
        {
            swap_icmp(icmp);
            dlen = len>sizeof(ICMPHDR) ? len-sizeof(ICMPHDR) : -1;
        }
        else
            i_printf("\nICMP checksum error: %04X\n", sum);
    }
    return(dlen);
}

/* Make an ICMP packet */
int make_icmp(GENFRAME *gfp, NODE *srcep, NODE *destp, BYTE type, BYTE code,
    WORD dlen)
{
    ICMPKT *icmp;
    WORD len;

    icmp = getframe_datap(gfp);
    icmp->c.type = type;
    icmp->c.code = code;
    icmp->c.check = 0;
    swap_icmp(icmp);
    len = (WORD)(dlen + sizeof(ICMPHDR));
    icmp->c.check = ~csum(&icmp->c, len);
    return(make_ip(gfp, srcep, destp, PICMP, len));
}

/* Make ICMP 'destination unreachable' for incoming frame */
int icmp_unreach(GENFRAME *gfp, NODE *srcep, NODE *destp, BYTE code)
{
    int len;
    ICMPKT *icmp;

    icmp = getframe_datap(gfp);
    len = ((icmp->i.vhl & 0xf) << 2) + 8;
    swap_ip(gfp);
    memmove(icmp->data, icmp, len);
    return(make_icmp(gfp, srcep, destp, ICUNREACH, code, (WORD)len));
}

/* Swap byte order of ints in ICMP header */
void swap_icmp(ICMPKT *icmp)
{
    icmp->c.ident = swapw(icmp->c.ident);
    icmp->c.seq = swapw(icmp->c.seq);
}

/* Return the maximum ICMP data size for a given frame without fragmentation */
int icmp_maxdata(GENFRAME *gfp)
{
    return(maxi(ip_maxdata(gfp)-sizeof(ICMPHDR), 0));
}

/* EOF */
LWORD atoip(char *str)
{
    LWORD ip=0L;
    int i=4, n;
    char c=1;

    while (--i>=0 && c)
    {
        n = 0;
        while ('0'<=(c=*str++)&&c<='9')
         n = n*10 + c-'0';
        ip += (LWORD)n << (i*8);
     }  
    return(ip);
}

char *ipstr(LWORD ip, char *s)
{
    sprintf(s, "%lu.%lu.%lu.%lu",(ip>>24)&255,(ip>>16)&255,(ip>>8)&255,ip&255);
    return(s);
  }
/*
char *ethstr(BYTE *addr, char *str)
{
    int i;
    char *s=str;

    if (!memcmp(addr, bcast2, MACLEN))
        strcpy(s, "----BROADCAST----");
    else for (i=0; i<MACLEN; i++)
        s += si_printf(s, i>0 ? ":%02x" : "%02x", *addr++);
    return(str);
}
*/

WORD buff_freelen(CBUFF *bp)
{
    return(bp->len ? bp->len - 1 - buff_dlen(bp) : 0);
}
/* Return total length of data in buffer */
WORD buff_dlen(CBUFF *bp)
{
    return((WORD)((bp->in - bp->out) & (bp->len - 1)));
}
WORD buff_in(CBUFF *bp, BYTE *data, WORD len)
{
    WORD in, n, n1, n2;

    in = (WORD)bp->in & (bp->len-1);        /* Mask I/P ptr to buffer area */
    n = minw(len, buff_freelen(bp));        /* Get max allowable length */
    n1 = minw(n, (WORD)(bp->len - in));     /* Length up to end of buff */
    n2 = n - n1;                            /* Length from start of buff */
    if (n1 && data)                         /* If anything to copy.. */
        memcpy(&bp->data[in], data, n1);    /* ..copy up to end of buffer.. */
    if (n2 && data)                         /* ..and maybe also.. */
        memcpy(bp->data, &data[n1], n2);    /* ..copy into start of buffer */
    bp->in += n;                            /* Bump I/P pointer */
    return(n);
}
/* Put packet onto network, given length */
WORD put_net(GENFRAME *gfp, WORD len)
{
    WORD dtype;
    SNAPFRAME *sfp;
    
    dtype = gfp->g.dtype;
    len = mini(len, getframe_maxlen(gfp));  /* Truncate if too big */
    gfp->g.len = len;
    if (dtype&DTYPE_SNAP && len+sizeof(SNAPHDR)<=MAXFRAME)
    {                                       /* If 802.3 SNAP.. */
        sfp = (SNAPFRAME *)gfp->buff;       /* Make room for new header */
        memmove(&sfp->s.ptype, &sfp->e.ptype, len);
        len += sizeof(SNAPHDR);             /* Set for 802.3 802.2 & SNAP */
        sfp->e.ptype = swapw((WORD)(len-sizeof(ETHERHDR)));
        sfp->s.lsap = 0xaaaa;
        sfp->s.ctrl = 3;
        memset(sfp->s.oui, 0, 3);
    }
    if (dtype & DTYPE_PKTD)                 /* If pkt drvr, send direct */
        len = DrvEthWrite(gfp->buff, len);
    else if (dtype & DTYPE_ETHER)           /* If an Ethernet frame.. */
    {                                       /* ..check space in pkt buffer.. */
        if (buff_freelen(&txpkts) >= len+sizeof(GENHDR))
            buff_in(&txpkts, (BYTE *)gfp, (WORD)(len+sizeof(GENHDR)));
    }
      else
        len = 0;
 
    return(len);
}
/* Put frame out onto the network; if sub-frame (fragment), send it as well */
int put_frame(GENFRAME *gfp, int len)
{
    int ret=0, len1, len2;
    GENFRAME *sfp;

    len1 = gfp->g.fragoff ? gfp->g.fragoff : len;   /* Get len of 2 fragments */
    len2 = len - len1;
    sfp = (GENFRAME *)&gfp->buff[gfp->g.fragoff];   /* ..and ptr to 2nd frag */
    if (len1 > 0)
        ret = put_net(gfp, (WORD)len1);
    if (len2 > 0)
        ret += put_net(sfp, (WORD)len2);
    return(ret);
}



void do_transmit(GENFRAME *gfp)
{
    ICMPKT *icmp;
    BYTE *data;
    int txlen;
    //i_printf("\nARP\r");                             /* Make packet */
   // txlen = make_arp(gfp, &locnode, &remnode, ARPREQ);
   
   //icmp = getframe_datap(gfp);                 /* Send echo req */
    //icmp->c.seq = ++txseq;
//#if ASCDATA
  //      data = testdata;                            /* ..using plain data */
//#else
//        data = &testdata[txseq%DATALEN];            /* ..or random */
//#endif
  //      memcpy(icmp->data, data, DATALEN);
    //    icmp->c.ident = 1;                          /* Make packet */
      //  txlen = make_icmp(gfp, &locnode, &remnode, ICREQ, 0, DATALEN);
        //txcount++;
        gfp->DTYPE_ETHER;  
   icmp = getframe_datap(gfp);                 /* Send echo req */
   icmp->c.seq = ++txseq;
   data = &testdata[txseq%DATALEN];            /* ..or random */
   memcpy(icmp->data, data, DATALEN);
   icmp->c.ident = 1;                          /* Make packet */
   txlen = make_icmp(gfp, &locnode, &remnode, ICREQ, 0, DATALEN);
   //put_frame(gfp, txlen);                          /* Transmit packet */
  DrvEthWrite(gfp,txlen);
   
}

void ping()
{
	WORD dtype;
        GENFRAME *gfp;
	LWORD remip; 
	LWORD lcip; 
	char *p, c, temps[18];
	char r[]={"10.1.2.74"};
	char l[]={"10.1.2.5"};
	
	char rm[]={"255.255.255.255"};
	char lm[]={"255.255.255.0"};
	
	char rg[]={"255.255.255.0"};
	char lg[]={"255.255.255.0"};
	
    	remip=atoip(r);
    	lcip=atoip(l);
    	remnode.ip = remip;
    	locnode.ip=lcip;
    	
    	remip=atoip(rm);
    	lcip=atoip(lm);
    	remnode.mask = remip;
    	locnode.mask=lcip;
    	
    	remip=atoip(rg);
    	lcip=atoip(lg);
    	remnode.gate = remip;
    	locnode.gate=lcip;
    	   	
    	memcpy(remnode.mac, bcast, MACLEN);     /* ..as broadcast */
    	memcpy(locnode.mac, bcast, MACLEN);     /* ..as broadcast */
    	i_printf("IP %s", ipstr(locnode.ip, temps));
        i_printf(" mask %s\n\r", ipstr(locnode.mask, temps));
    	do_transmit(gfp);    	
    		
}