netutil.h

这是三星评估板ws310(CPU为S3c4510B)用的Bootloader.开发环境是SDT。

/* Network utility definitions for 'TCP/IP Lean' */

/* Define variable sizes: 8, 16, 32 bits */
#ifndef BYTE
#define BYTE unsigned char
#endif
#ifndef WORD
#define WORD unsigned short
#endif
#ifndef LWORD
#define LWORD unsigned long
#endif

/* Ensure network structures aren't padded (DJGPP and VC) */
//#pragma pack(1)

/*******************************************************************/
/*net.h*/
/******************************************************************/
#define PCOL_SCRATCHP   0xfeeb      /* Protocol ID for SCRATCHP */
#define MAXSLIP         1006        /* Max SLIP frame size */

#define MAXNETS         4           /* Max net interfaces, must be power of 2 */

/* Driver type bits returned by 'open_net'
** If l.s.byte is zero, use direct hardware interface.
** If non-zero, is an interrupt number (i.e. handle) for packet driver access */
#define DTYPE_ETHER     0x8000      /* Ethernet frame */
#define DTYPE_SNAP      0x4000      /* 802.3 SNAP header option */
#define DTYPE_SLIP      0x2000      /* SLIP frame */
#define DTYPE_PKTD      0x0010      /* PC packet driver interface */
#define DTYPE_NE        0x0020      /* Direct NE2000-compatible driver */
#define DTYPE_3C        0x0040      /* Direct 3COM 3C509 driver */
#define DTYPE_SER       0x0100      /* PC serial driver (direct or Win32) */
#define NETNUM_MASK     (MAXNETS-1) /* Mask for network number */

BYTE bcast[MACLEN] = {BCASTADDR};   /* Broadcast MAC addr */

/* General-purpose frame header, and frame including header */
typedef struct {
    WORD len;                   /* Length of data in genframe buffer */
    WORD dtype;                 /* Driver type */
    WORD fragoff;               /* Offset of fragment within buffer */
} GENHDR;

/* The general-pupose frame buffer is dimensioned to accomodate 2 fragments
** i.e.  a 1514-byte frame, a 2nd GENHDR, and a 2nd 1514-byte frame */
#define MAXGEN 3040
typedef struct {
    GENHDR g;                   /* General-pupose frame header */
    BYTE buff[MAXGEN];          /* Frame itself (2 frames if fragmented) */
} GENFRAME;

/* Default circular buffer size: MUST be power of 2
** This definition is for initialisation only, and may be overriden to
** create a larger or smaller buffer. To determine the actual buffer size, all
** functions MUST use the 'len' value below, not the _CBUFFLEN_ definition */
#ifndef _CBUFFLEN_
#define _CBUFFLEN_ 0x800
#endif
/* Circular buffer structure */
typedef struct
{
    WORD len;                   /* Length of data (must be first) */
    LWORD in;                   /* Incoming data */
    LWORD out;                  /* Outgoing data */
    LWORD trial;                /* Outgoing data 'on trial' */
    BYTE data[_CBUFFLEN_];      /* Buffer */
} CBUFF;
/*****************************************************************************/
/*netutil.c************************************/
/********************************************************************************/
int getframe_maxlen(GENFRAME *gfp)
{
    return(gfp->g.dtype&DTYPE_ETHER ? MAXFRAME : MAXSLIP);
}

WORD getframe_pcol(GENFRAME *gfp)
{
    ETHERHDR *ehp;
    WORD pcol=0;

    if (gfp->g.dtype & DTYPE_ETHER)         /* Only Ethernet has protocol */
    {
        ehp = (ETHERHDR *)gfp->buff;
        pcol = ehp->ptype;
    }
    return(pcol);
}

void *getframe_datap(GENFRAME *gfp)
{
    return(&gfp->buff[dtype_hdrlen(gfp->g.dtype)]);
}

int dtype_hdrlen(int dtype)
{
    return(dtype&DTYPE_ETHER ? sizeof(ETHERHDR) : 0);
}

void swap_ether(GENFRAME *gfp)
{
    ETHERFRAME *efp;

    efp = (ETHERFRAME *)gfp->buff;
    efp->h.ptype = swapw(efp->h.ptype);
}


int make_frame(GENFRAME *gfp, BYTE dest[], WORD pcol, WORD dlen)
{
    ETHERHDR *ehp;

    if (gfp->g.dtype & DTYPE_ETHER)
    {
        ehp = (ETHERHDR *)gfp->buff;
        ehp->ptype = pcol;
        memcpy(ehp->dest, dest, MACLEN);
        swap_ether(gfp);
        dlen += sizeof(ETHERHDR);
    }
    return(dlen);
}
int swapw(int w)
{
    return(((w<<8)&0xff00) | ((w>>8)&0x00ff));
}


LWORD swapl(LWORD lw)
{
    return(((lw<<24)&0xff000000L) | ((lw<<8 )&0x00ff0000L) |
           ((lw>>8 )&0x0000ff00L) | ((lw>>24)&0x000000ffL));
}

WORD csum(void *dp, WORD count)
{
    register LWORD total=0L;
    register WORD n, *p, carries;

    n = count / 2;
    p = (WORD *)dp;
    while (n--)
        total += *p++;
    if (count & 1)
        total += *(BYTE *)p;
    while ((carries=(WORD)(total>>16))!=0)
        total = (total & 0xffffL) + carries;
    return((WORD)total);
}

WORD minw(WORD a, WORD b)
{
    return(a<b ? a : b);
}
WORD maxw(WORD a, WORD b)
{
    return(a>b ? a : b);
}
int mini(int a, int b)
{
    return(a<b ? a : b);
}
int maxi(int a, int b)
{
    return(a>b ? a : b);
}

WORD getframe_mtu(GENFRAME *gfp)
{
    WORD mtu;

    mtu = (WORD)getframe_maxlen(gfp);
    if (gfp->g.dtype & DTYPE_ETHER)
    {
        mtu -= sizeof(ETHERHDR);
        if (gfp->g.dtype & DTYPE_SNAP)
            mtu -= sizeof(SNAPHDR);
    }
    return(mtu);
}


BYTE *getframe_srcep(GENFRAME *gfp)
{
    ETHERHDR *ehp;
    BYTE *srce=0;

    if (gfp->g.dtype & DTYPE_ETHER)         /* Only Ethernet has address */
    {
        ehp = (ETHERHDR *)gfp->buff;
        srce = ehp->srce;
    }
    return(srce);
}
BYTE *getframe_srce(GENFRAME *gfp, BYTE *buff)
{
    BYTE *p;

    p = getframe_srcep(gfp);
    if (p)
        memcpy(buff, p, MACLEN);
    else
        memcpy(buff, bcast, MACLEN);
    return(p);
}

BYTE *getframe_destp(GENFRAME *gfp)
{
    ETHERHDR *ehp;
    BYTE *dest=0;

    if (gfp->g.dtype & DTYPE_ETHER)         /* Only Ethernet has address */
    {
        ehp = (ETHERHDR *)gfp->buff;
        dest = ehp->dest;
    }
    return(dest);
}

BYTE *getframe_dest(GENFRAME *gfp, BYTE *buff)
{
    BYTE *p;

    p = getframe_destp(gfp);
    if (p)
        memcpy(buff, p, MACLEN);
    else
        memcpy(buff, bcast, MACLEN);
    return(p);
}

/* Get pointer to the destination address of the given frame, 0 if none */

/* Prototypes */
int getframe_maxlen(GENFRAME *gfp);
WORD getframe_mtu(GENFRAME *gfp);
//WORD dtype_hdrlen(WORD dtype);
void *getframe_datap(GENFRAME *gfp);
BYTE *getframe_srcep(GENFRAME *gfp);
BYTE *getframe_srce(GENFRAME *gfp, BYTE *buff);
BYTE *getframe_destp(GENFRAME *gfp);
BYTE *getframe_dest(GENFRAME *gfp, BYTE *buff);
WORD getframe_pcol(GENFRAME *gfp);
int is_bcast(GENFRAME *gfp);
int is_ether(GENFRAME *gfp, int len);
//int make_frame(GENFRAME *gfp, BYTE dest[], WORD pcol, WORD dlen);
//void swap_ether(GENFRAME *gfp);
void disp_ether(GENFRAME *gfp, int dlen);
int is_slip(GENFRAME *gfp, int len);
void disp_frame(GENFRAME *gfp, int dlen, int tx);
char *ipstr(LWORD ip, char *s);
char *ethstr(BYTE *addr, char *str);
LWORD atoip(char *str);
int read_cfgval(char *fname, char *item, int *valp);
int read_cfgstr(char *fname, char *item, char *dest, int destlen);
int read_cfgstr_n(char *fname, int n, char *item, char *dest, int destlen);
int read_cfgopt(char *fname, char *item, char *opt);
char *skiptoken(char *str, char *tok);
char *skipspace(char *str);
char *skippunct(char *str);
int in_limits(LWORD val, LWORD lo, LWORD hi);
void buff_setall(CBUFF *bp, LWORD start);
WORD buff_freelen(CBUFF *bp);
WORD buff_untriedlen(CBUFF *bp);
WORD buff_trylen(CBUFF *bp);
WORD buff_dlen(CBUFF *bp);
WORD buff_retry(CBUFF *bp, WORD len);
WORD buff_preload(CBUFF *bp, LWORD oset, BYTE *data, WORD len);
WORD buff_in(CBUFF *bp, BYTE *data, WORD len);
WORD buff_instr(CBUFF *bp, char *str);
WORD buff_infile(CBUFF *bp, FILE *fp, WORD len);
WORD buff_try(CBUFF *bp, BYTE *data, WORD maxlen);
WORD buff_out(CBUFF *bp, BYTE *data, WORD maxlen);
WORD buff_strlen(CBUFF *bp);
WORD buff_chrlen(CBUFF *bp, char c);
WORD csum(void *dp, WORD count);
WORD minw(WORD a, WORD b);
WORD maxw(WORD a, WORD b);
int mini(int a, int b);
int maxi(int a, int b);
//WORD swapw(WORD w);
LWORD swapl(LWORD lw);
int timeout(WORD *timep, int sec);
int mstimeout(LWORD *timep, int msec);
LWORD mstime(void);
void msdelay(WORD millisec);
void hexdump(BYTE *buff, WORD len);
char *find_first(char *path);
char *find_next(void);
long find_filesize(void);

/* EOF */