[OpenSPARC-T2-SAM] / sam-t2 / sam / include / eth.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: eth.h
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
* 
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
* 
* The above named program is distributed in the hope that it will be 
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
* 
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
* 
* ========== Copyright Header End ============================================
*/
/*
 *	"eth.h"
 *
 *	structs & functions to access ethernet packet fields...
 *
 * Note, for when ip.verlen = 0x45, ie standard 5-word (20-uchar) ip-header,
 *       and when tcp.?? = ??, ie standard 20-uchar tcp header:
 *
 *	min eth-pkt = 64 uchars 
 *		     -14 (eth-header)
 *	              -4 (eth-tailer CRC)  = 46 min eth-data
 *	             -20 (ip-header)       = 26 min padding for "empty" ip-pkt
 *	             -20 (tcp-header)      = 6 min padding for "empty" tcp-pkt
 *
 *	max eth-pkt = 1518 uchars
 *		      - 14 (eth-header)
 *	               - 4 (eth-trailer CRC)  = 1500 max eth-data-MTU
 *	              - 20 (ip-header)        = 1480 max ip-data-MTU
 *	              - 20 (tcp-header)       = 1460 max tcp-data-MTU
 *
 *
 * all of the "word" sized fields are UN-aligned, Argh!!!...
 *
 * @@@ Danger Will Robinson, Danger:
 *	 -1 and -2 seem to be valid ip addresses ???
 */
#ifndef _ETH_H
#define _ETH_H

typedef unsigned char  uchar;
typedef unsigned short ushort;
typedef unsigned int   uword;


#define ETH_MAX 1518		/* the whole thing, including header and CRC */
#define ETH_BUF_MAX 1514	/* without the CRC */
#define ETH_DATA_MAX 1500	/* without the CRC or the header, aka `MTU' */

#define ETHHDRSZ 14		/* ethernet packet header size */

#define ETH_MIN 64		/* the whole thing, including header and CRC */

#define IP_DATA_MAX 1480	/* eth minus the 20-uchar ip header */
#define TCP_DATA_MAX 1460	/* ip minus the 20-uchar tcp header */


/* Ethernet Types */
#define ET_IPv4 0x0800
#define ET_ARP  0x0806
#define ET_RARP 0x0835


/* (some) IP Types */
#define IP_ICMP 0x01		/* Inet Control Message Prot	<--- */
#define IP_IGMP 0x02		/* Inet Gateway Message Prot	<--- */
#define IP_GGP  0x03		/* Gateway-to-Gateway Prot */
#define IP_IP   0x04		/* IP-in-IP-encapsulation Prot */
#define IP_ST   0x05		/* Stream Prot */
#define IP_TCP  0x06		/* Transmission Control Prot	<--- */
#define IP_EGP  0x08		/* Exterior-Gateway Prot */
#define IP_IGP  0x09		/* Interior-Gateway Prot */
#define IP_UDP  0x11		/* User Datagram Prot		<--- */

/* (some) ICMP message Types */
#define ICMP_ECHOREPLY 0
#define ICMP_UNREACHABLE 3
#define ICMP_SRCQUENCH 4
#define ICMP_REDIRECT 5
#define ICMP_ECHO 8
#define ICMP_ROUTERREPLY 9
#define ICMP_ROUTERREQST 10
#define ICMP_TIMEOUT 11
#define ICMP_INVARG 12
#define ICMP_TIMESTAMP 13
#define ICMP_TSTAMPREPLY 14
#define ICMP_INFO 15
#define ICMP_INFOREPLY 16
#define ICMP_MASK 17
#define ICMP_MASKREPLY 18
#define ICMP_DOMNAMREQST 37
#define ICMP_DOMNAMREPLY 38


/* (a few) TCP Types */
#define TCP_ECHO 7
#define TCP_FTPDATA 20
#define TCP_FTP 21
#define TCP_SSH 22
#define TCP_TELNET 23
#define TCP_TIME 37
#define TCP_DNS 53
#define TCP_HTTP 80
#define TCP_HTTPS 443
#define TCP_SUNRPC 111
#define TCP_LDAP 389
#define TCP_REXEC 512
#define TCP_RLOGIN 513
#define TCP_RSHELL 514


typedef struct {
	uchar	dstMAC[6];		/* all 1's for a broadcast Request   0*/
	uchar	srcMAC[6];		/*                                   3*/
	ushort	frametype;		/* 0x0800 => ET_IPv4		     6*/
					/* 0x0806 => ARP,  0x0835 => RARP     */
	union {

	char eth_data[ ETH_DATA_MAX ];

	struct arp_s {
		ushort	hardtype;	/* 1 => Ethernet		     7*/
		ushort	prottype;	/* 0x0800 => IP			     8*/
		uchar	hardsize;	/* 6, mac size			     9*/
		uchar	protsize;	/* 4, ip size */
		ushort	op;		/* 1 => ARP, 2 => reply,
					   3 => RARP, 4 => reply	    10*/
					/* ARP-Request		ARP-Reply     */
		uchar	srcMAC[6];	/* requestor     -----> replyor     11*/
		uchar	srcIP[4];	/* requestor    / ----> replyor     14*/
		uchar	dstMAC[6];	/*  <empty>----- /                  16*/
		uchar	dstIP[4];	/* specified-----                   19*/
	} arp;

	struct ip_s {
		uchar	verlen;		/* 0x45 -> IPv4 and std 5-word header */
		uchar	TofS;
		ushort	iplen;		/* ipheader + ipdata, NOT incl eth hdr*/
		ushort	ident;
		ushort	flags;
		uchar	time_to_live;
		uchar	protocol;	/* 0x06=>TCP, 0x11=>UDP, 0x01=> ICMP */
		ushort	hdrchecksum;
		uchar	srcIP[4];					/*  13*/
		uchar	dstIP[4];					/*  15*/

		union {

		char ip_data [ IP_DATA_MAX ];

		struct icmp_s {
			char	type;
			char	code;
			ushort	chksum;
		} icmp;

		struct udp_s {
			ushort	srcPORT;
			ushort	dstPORT;
			ushort	udplen;
			ushort	checksum;
		} udp;

		struct tcp_s {
			ushort	srcPORT;				/*  17*/
			ushort	dstPORT;				/*  18*/
			uchar	SeqNum[4];
			uchar	AckNum[4];
			ushort	flags;
			ushort	win_size;
			ushort	checksum;
			ushort	UrgentPtr;

			uchar	data[6]; /*min padding for "empty" pkt*/
		} tcp;

		} u;

	} ip;

	} u;

	char CRC[4];
	char guard[120];	/* protect from buffer overflow... */
} ethpacket_t;


								      /* short*/
typedef struct {						      /*offset*/
	uchar	dstMAC[6];
	uchar	srcMAC[6];
	ushort	frametype;		/* 0x0800 -> ET_IPv4		     6*/
	struct {
		uchar	verlen;		/* 0x45 -> std IP hdr                7*/
		uchar	TofS;
		ushort	iplen;		/* 20 for empty data packet */
		ushort	ident;
		ushort	flags;
		uchar	time_to_live;
		uchar	protocol;	/* 0xff -> netsim connect packet    11*/
		ushort	hdrchecksum;
		uchar	srcIP[4];					/*  13*/
		uchar	dstIP[4];					/*  15*/
	} ip;
} netsim_connect_packet;


inline uint16_t eth_short (uchar * x)
		{ return ((unsigned short*)(x))[0]; }

inline uint32_t eth_int (uchar * x)
		{ return (((unsigned short*)(x))[0])<<16
		       | (((unsigned short*)(x))[1]); }

inline uint64_t eth_long (uchar * x)
	{ return ((uint64_t)(((unsigned short*)(x))[0])<<32)
	       | ((uint64_t)(((unsigned short*)(x))[1])<<16)
	       |  (uint64_t)(((unsigned short*)(x))[2]); }


inline bool eth_isbroadcast(ethpacket_t * x)
	{ return eth_short (&x->dstMAC[0]) == 0xffff
	      && eth_short (&x->dstMAC[2]) == 0xffff
	      && eth_short (&x->dstMAC[4]) == 0xffff; }


inline int eth_length (ethpacket_t * x)
	{
		if (x->frametype == ET_ARP) return 42;
		else if (x->frametype == ET_IPv4)
			return ETHHDRSZ + x->u.ip.iplen;
		else return 0; /* ??? */
	}


inline unsigned short eth_type (ethpacket_t * x)	/* arp, ipv4, ... */
				{ return x->frametype; }

inline unsigned short eth_arpop (ethpacket_t * x)	/* reqest, reply, */
				{ return x->u.arp.op; }

inline unsigned char eth_ipproto (ethpacket_t * x)	/* tcp, upd, icmp,...*/
				{ return x->u.ip.protocol; }

inline unsigned char eth_ipversion (ethpacket_t * x)
				{ return x->u.ip.verlen >> 4; }

inline unsigned char eth_iphdrlen (ethpacket_t * x)
				{ return 4 * (x->u.ip.verlen & 0xf); }

inline unsigned char eth_ipverlen (ethpacket_t * x)
				{ return x->u.ip.verlen; }

inline unsigned char eth_icmptype (ethpacket_t * x)
				{ return x->u.ip.u.icmp.type; }

inline unsigned char eth_icmpcode (ethpacket_t * x)
				{ return x->u.ip.u.icmp.code; }

/*
inline unsigned char eth_tcptype (ethpacket_t * x)
				{ return x->u.ip.u.tcp.protocol; }
	* I think we have to look for "known" tcp port numbers... *
*/

inline bool eth_tcpzlenack (ethpacket_t * x)
	{ return  (x->frametype == ET_IPv4)
		&& (x->u.ip.iplen == 40)
		&& (x->u.ip.protocol == IP_TCP)
		&& (x->u.ip.u.tcp.flags & 0x10); }


				/* fetch MAC addresses */
inline uint64_t eth_srcMAC(ethpacket_t * x)
			{ return eth_long (x->srcMAC); }
inline uint64_t eth_dstMAC(ethpacket_t * x)
			{ return eth_long (x->dstMAC); }

inline void sprint_MACaddr (char * buf, uint64_t mac)
{
  sprintf (buf, "%02x:%02x:%02x:%02x:%02x:%02x",	/* char buf[18] */
	(int)(mac>>40)&0xff, (int)(mac>>32)&0xff, (int)(mac>>24)&0xff,
	(int)(mac>>16)&0xff, (int)(mac>>8)&0xff, (int)(mac>>0)&0xff);
}


				/* fetch IP addresses */
inline uint32_t eth_srcIP(ethpacket_t * x)
{
	if (eth_type (x) == ET_ARP) return eth_int (x->u.arp.srcIP);
	else if (eth_type (x) == ET_IPv4)
		return eth_int (x->u.ip.srcIP);
	else return 0;
}
inline uint32_t eth_dstIP(ethpacket_t * x)
{
	if (eth_type (x) == ET_ARP) return eth_int (x->u.arp.dstIP);
	else if (eth_type (x) == ET_IPv4)
		return eth_int (x->u.ip.dstIP);
	else return 0;
}

inline void sprint_IPaddr (char * buf, uint32_t ip)	/* char buf[16] */
{
  sprintf (buf, "%d:%d:%d:%d",
	(ip>>24)&0xff, (ip>>16)&0xff, (ip>>8)&0xff, (ip>>0)&0xff);
}

inline uint32_t sscan_IPaddr (char * buf)
{
  unsigned int i1,i2,i3,i4;
  if (sscanf (buf, "%d:%d:%d:%d", &i1, &i2, &i3, &i4) == 4) {
	return (i1&0xff)<<24 | (i2&0xff)<<16 | (i3&0xff)<<8 | (i4&0xff)<<0;
  } else
	return 0xffffffff;
}


				/* fetch TCP addresses */
inline uint32_t eth_srcPORT(ethpacket_t * x)
{
        if (eth_type (x) == ET_IPv4 
	    && eth_ipverlen (x) == 0x45
	    && eth_ipproto (x) == IP_TCP)
		return x->u.ip.u.tcp.srcPORT;
	else
		return -1;
}
inline uint32_t eth_dstPORT(ethpacket_t * x)
{
        if (eth_type (x) == ET_IPv4 
	    && eth_ipverlen (x) == 0x45
	    && eth_ipproto (x) == IP_TCP)
		return x->u.ip.u.tcp.dstPORT;
	else
		return -1;
}


#if 1

const char * eth_tcp_string (int tcptype);

const char * eth_icmp_string (int icmptype, int icmpcode);


#else	/*** see "netsim.cc" ***/

char * eth_tcp_string (int tcptype)
{
    static char buf[10];

    switch (tcptype) {
	case TCP_ECHO:	  return "echo";
	case TCP_FTPDATA: return "ftpdata";
	case TCP_FTP:	  return "ftp";
	case TCP_SSH:	  return "ssh";
	case TCP_TELNET:  return "telnet";
	case TCP_TIME:	  return "time";
	case TCP_DNS:	  return "dns";
	case TCP_HTTP:	  return "http";
	case TCP_HTTPS:	  return "https";
	case TCP_SUNRPC:  return "sunrpc";
	case TCP_LDAP:	  return "ldap";
	case TCP_REXEC:	  return "rexec";
	case TCP_RLOGIN:  return "rlogin";
	case TCP_RSHELL:  return "rshell";
	default:
		sprintf(&buf[0], "%d", tcptype);
		return &buf[0];
    }
}

char * eth_icmp_string (int icmptype, int icmpcode)
{
    static char buf[10];

    switch (icmptype) {
	case ICMP_ECHOREPLY:	return "echo_reply";
	case ICMP_UNREACHABLE:
	    switch (icmpcode) {
	    case 0:		return "network_unreachable";
	    case 1:		return "host_unreachable";
	    case 2:		return "protocol_unreachable";
	    case 3:		return "port_unreachable";
	    case 4:		return "fragment_unreachable";
	    case 5:		return "route_unreachable";
	    case 6:		return "network_unknown";
	    case 7:		return "host_unknown";
	    case 8:		return "obsolete_unreachable";
	    case 9:		return "network_prohibited";
	    case 10:		return "host_prohibited";
	    case 11:		return "network_tos_unreachable";
	    case 12:		return "host_tos_unreachable";
	    default:		return "unreachable_?";
	    }
	case ICMP_SRCQUENCH:	return "source_quench";
	case ICMP_REDIRECT:
	    switch (icmpcode) {
	    case 0:		return "redirect_network";
	    case 1:		return "redirect_host";
	    case 2:		return "redirect_tos_network";
	    case 3:		return "redirect_tos_host";
	    default:		return "redirect_?";
	    }
	case ICMP_ECHO:		return "echo_request";
	case ICMP_ROUTERREPLY:	return "router_reply";
	case ICMP_ROUTERREQST:	return "router_request";
	case ICMP_TIMEOUT:	return "time_exceeded";
	case ICMP_INVARG:	return "invalid_parameter";
	case ICMP_TIMESTAMP:	return "timestamp_request";
	case ICMP_TSTAMPREPLY:	return "timestamp_reply";
	case ICMP_INFO:		return "obsolete_request";
	case ICMP_INFOREPLY:	return "obsolete_reply";
	case ICMP_MASK:		return "mask_request";
	case ICMP_MASKREPLY:	return "mask_reply";
	default:
		sprintf(&buf[0], "%d", icmptype);
		return &buf[0];
    }
}

#endif


#if 0	/*** see  "netsim.cc"/netsim_dbgpacket()  ***/
void eth_print ()
{
	int et,ipt;
	et = eth_type(&buffer.packet);
	fprintf (stderr, "eth{%02x->%02x,%s",
			eth_srcMAC(&buffer.packet) & 0xff,
			eth_dstMAC(&buffer.packet) & 0xff,
			(et == ET_IPv4 : "ip" ?
			 et == ET_ARP : "arp" ?
			 et == ET_RARP : "rarp" ? "?") );
	switch (et) {
	case ET_IPv4:
		ipt = eth_ipproto(&buffer.packet);
		fprintf (stderr, "{%d.%d->%d.%d,%s",
			eth_srcIP(&buffer.packet) & 0xff,
			eth_dstIP(&buffer.packet) & 0xff,
			ipt);
		break;
	case ET_ARP:
		fprintf (stderr, "{
		break;
	case ET_RARP:
		break;
	}
	fprintf (stderr, "}\n");
		
}
#endif


#endif /*_ETH_H*/
Commit	Line	Data
920dae64 AT	1	/*
	2	* ========== Copyright Header Begin ==========================================
	3	*
	4	* OpenSPARC T2 Processor File: eth.h
	5	* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
	6	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
	7	*
	8	* The above named program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public
	10	* License version 2 as published by the Free Software Foundation.
	11	*
	12	* The above named program is distributed in the hope that it will be
	13	* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public
	18	* License along with this work; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
	20	*
	21	* ========== Copyright Header End ============================================
	22	*/
	23	/*
	24	* "eth.h"
	25	*
	26	* structs & functions to access ethernet packet fields...
	27	*
	28	* Note, for when ip.verlen = 0x45, ie standard 5-word (20-uchar) ip-header,
	29	* and when tcp.?? = ??, ie standard 20-uchar tcp header:
	30	*
	31	* min eth-pkt = 64 uchars
	32	* -14 (eth-header)
	33	* -4 (eth-tailer CRC) = 46 min eth-data
	34	* -20 (ip-header) = 26 min padding for "empty" ip-pkt
	35	* -20 (tcp-header) = 6 min padding for "empty" tcp-pkt
	36	*
	37	* max eth-pkt = 1518 uchars
	38	* - 14 (eth-header)
	39	* - 4 (eth-trailer CRC) = 1500 max eth-data-MTU
	40	* - 20 (ip-header) = 1480 max ip-data-MTU
	41	* - 20 (tcp-header) = 1460 max tcp-data-MTU
	42	*
	43	*
	44	* all of the "word" sized fields are UN-aligned, Argh!!!...
	45	*
	46	* @@@ Danger Will Robinson, Danger:
	47	* -1 and -2 seem to be valid ip addresses ???
	48	*/
	49	#ifndef _ETH_H
	50	#define _ETH_H
	51
	52	typedef unsigned char uchar;
	53	typedef unsigned short ushort;
	54	typedef unsigned int uword;
	55
	56
	57	#define ETH_MAX 1518 /* the whole thing, including header and CRC */
	58	#define ETH_BUF_MAX 1514 /* without the CRC */
	59	#define ETH_DATA_MAX 1500 /* without the CRC or the header, aka `MTU' */
	60
	61	#define ETHHDRSZ 14 /* ethernet packet header size */
	62
	63	#define ETH_MIN 64 /* the whole thing, including header and CRC */
	64
65	#define IP_DATA_MAX 1480 /* eth minus the 20-uchar ip header */
66	#define TCP_DATA_MAX 1460 /* ip minus the 20-uchar tcp header */
67
68
69	/* Ethernet Types */
70	#define ET_IPv4 0x0800
71	#define ET_ARP 0x0806
72	#define ET_RARP 0x0835
73
74
75	/* (some) IP Types */
76	#define IP_ICMP 0x01 /* Inet Control Message Prot <--- */
77	#define IP_IGMP 0x02 /* Inet Gateway Message Prot <--- */
78	#define IP_GGP 0x03 /* Gateway-to-Gateway Prot */
79	#define IP_IP 0x04 /* IP-in-IP-encapsulation Prot */
80	#define IP_ST 0x05 /* Stream Prot */
81	#define IP_TCP 0x06 /* Transmission Control Prot <--- */
82	#define IP_EGP 0x08 /* Exterior-Gateway Prot */
83	#define IP_IGP 0x09 /* Interior-Gateway Prot */
84	#define IP_UDP 0x11 /* User Datagram Prot <--- */
85
86	/* (some) ICMP message Types */
87	#define ICMP_ECHOREPLY 0
88	#define ICMP_UNREACHABLE 3
89	#define ICMP_SRCQUENCH 4
90	#define ICMP_REDIRECT 5
91	#define ICMP_ECHO 8
92	#define ICMP_ROUTERREPLY 9
93	#define ICMP_ROUTERREQST 10
94	#define ICMP_TIMEOUT 11
95	#define ICMP_INVARG 12
96	#define ICMP_TIMESTAMP 13
97	#define ICMP_TSTAMPREPLY 14
98	#define ICMP_INFO 15
99	#define ICMP_INFOREPLY 16
100	#define ICMP_MASK 17
101	#define ICMP_MASKREPLY 18
102	#define ICMP_DOMNAMREQST 37
103	#define ICMP_DOMNAMREPLY 38
104
105
106	/* (a few) TCP Types */
107	#define TCP_ECHO 7
108	#define TCP_FTPDATA 20
109	#define TCP_FTP 21
110	#define TCP_SSH 22
111	#define TCP_TELNET 23
112	#define TCP_TIME 37
113	#define TCP_DNS 53
114	#define TCP_HTTP 80
115	#define TCP_HTTPS 443
116	#define TCP_SUNRPC 111
117	#define TCP_LDAP 389
118	#define TCP_REXEC 512
119	#define TCP_RLOGIN 513
120	#define TCP_RSHELL 514
121
122
123
124
125	typedef struct {
126	uchar dstMAC[6]; /* all 1's for a broadcast Request 0*/
127	uchar srcMAC[6]; /* 3*/
128	ushort frametype; /* 0x0800 => ET_IPv4 6*/
129	/* 0x0806 => ARP, 0x0835 => RARP */
130	union {
131
132	char eth_data[ ETH_DATA_MAX ];
133
134	struct arp_s {
135	ushort hardtype; /* 1 => Ethernet 7*/
136	ushort prottype; /* 0x0800 => IP 8*/
137	uchar hardsize; /* 6, mac size 9*/
138	uchar protsize; /* 4, ip size */
139	ushort op; /* 1 => ARP, 2 => reply,
140	3 => RARP, 4 => reply 10*/
141	/* ARP-Request ARP-Reply */
142	uchar srcMAC[6]; /* requestor -----> replyor 11*/
143	uchar srcIP[4]; /* requestor / ----> replyor 14*/
144	uchar dstMAC[6]; /* <empty>----- / 16*/
145	uchar dstIP[4]; /* specified----- 19*/
146	} arp;
147
148	struct ip_s {
149	uchar verlen; /* 0x45 -> IPv4 and std 5-word header */
150	uchar TofS;
151	ushort iplen; /* ipheader + ipdata, NOT incl eth hdr*/
152	ushort ident;
153	ushort flags;
154	uchar time_to_live;
155	uchar protocol; /* 0x06=>TCP, 0x11=>UDP, 0x01=> ICMP */
156	ushort hdrchecksum;
157	uchar srcIP[4]; /* 13*/
158	uchar dstIP[4]; /* 15*/
159
160	union {
161
162	char ip_data [ IP_DATA_MAX ];
163
164	struct icmp_s {
165	char type;
166	char code;
167	ushort chksum;
168	} icmp;
169
170	struct udp_s {
171	ushort srcPORT;
172	ushort dstPORT;
173	ushort udplen;
174	ushort checksum;
175	} udp;
176
177	struct tcp_s {
178	ushort srcPORT; /* 17*/
179	ushort dstPORT; /* 18*/
180	uchar SeqNum[4];
181	uchar AckNum[4];
182	ushort flags;
183	ushort win_size;
184	ushort checksum;
185	ushort UrgentPtr;
186
187	uchar data[6]; /min padding for "empty" pkt/
188	} tcp;
189
190	} u;
191
192	} ip;
193
194	} u;
195
196	char CRC[4];
197	char guard[120]; /* protect from buffer overflow... */
198	} ethpacket_t;
199
200
201	/* short*/
202	typedef struct { /offset/
203	uchar dstMAC[6];
204	uchar srcMAC[6];
205	ushort frametype; /* 0x0800 -> ET_IPv4 6*/
206	struct {
207	uchar verlen; /* 0x45 -> std IP hdr 7*/
208	uchar TofS;
209	ushort iplen; /* 20 for empty data packet */
210	ushort ident;
211	ushort flags;
212	uchar time_to_live;
213	uchar protocol; /* 0xff -> netsim connect packet 11*/
214	ushort hdrchecksum;
215	uchar srcIP[4]; /* 13*/
216	uchar dstIP[4]; /* 15*/
217	} ip;
218	} netsim_connect_packet;
219
220
221
222
223	inline uint16_t eth_short (uchar * x)
224	{ return ((unsigned short*)(x))[0]; }
225
226	inline uint32_t eth_int (uchar * x)
227	{ return (((unsigned short*)(x))[0])<<16
228	\| (((unsigned short*)(x))[1]); }
229
230	inline uint64_t eth_long (uchar * x)
231	{ return ((uint64_t)(((unsigned short*)(x))[0])<<32)
232	\| ((uint64_t)(((unsigned short*)(x))[1])<<16)
233	\| (uint64_t)(((unsigned short*)(x))[2]); }
234
235
236	inline bool eth_isbroadcast(ethpacket_t * x)
237	{ return eth_short (&x->dstMAC[0]) == 0xffff
238	&& eth_short (&x->dstMAC[2]) == 0xffff
239	&& eth_short (&x->dstMAC[4]) == 0xffff; }
240
241
242	inline int eth_length (ethpacket_t * x)
243	{
244	if (x->frametype == ET_ARP) return 42;
245	else if (x->frametype == ET_IPv4)
246	return ETHHDRSZ + x->u.ip.iplen;
247	else return 0; /* ??? */
248	}
249
250
251	inline unsigned short eth_type (ethpacket_t * x) /* arp, ipv4, ... */
252	{ return x->frametype; }
253
254	inline unsigned short eth_arpop (ethpacket_t * x) /* reqest, reply, */
255	{ return x->u.arp.op; }
256
257	inline unsigned char eth_ipproto (ethpacket_t * x) /* tcp, upd, icmp,...*/
258	{ return x->u.ip.protocol; }
259
260	inline unsigned char eth_ipversion (ethpacket_t * x)
261	{ return x->u.ip.verlen >> 4; }
262
263	inline unsigned char eth_iphdrlen (ethpacket_t * x)
264	{ return 4 * (x->u.ip.verlen & 0xf); }
265
266	inline unsigned char eth_ipverlen (ethpacket_t * x)
267	{ return x->u.ip.verlen; }
268
269	inline unsigned char eth_icmptype (ethpacket_t * x)
270	{ return x->u.ip.u.icmp.type; }
271
272	inline unsigned char eth_icmpcode (ethpacket_t * x)
273	{ return x->u.ip.u.icmp.code; }
274
275	/*
276	inline unsigned char eth_tcptype (ethpacket_t * x)
277	{ return x->u.ip.u.tcp.protocol; }
278	* I think we have to look for "known" tcp port numbers... *
279	*/
280
281	inline bool eth_tcpzlenack (ethpacket_t * x)
282	{ return (x->frametype == ET_IPv4)
283	&& (x->u.ip.iplen == 40)
284	&& (x->u.ip.protocol == IP_TCP)
285	&& (x->u.ip.u.tcp.flags & 0x10); }
286
287
288
289	/* fetch MAC addresses */
290	inline uint64_t eth_srcMAC(ethpacket_t * x)
291	{ return eth_long (x->srcMAC); }
292	inline uint64_t eth_dstMAC(ethpacket_t * x)
293	{ return eth_long (x->dstMAC); }
294
295	inline void sprint_MACaddr (char * buf, uint64_t mac)
296	{
297	sprintf (buf, "%02x:%02x:%02x:%02x:%02x:%02x", /* char buf[18] */
298	(int)(mac>>40)&0xff, (int)(mac>>32)&0xff, (int)(mac>>24)&0xff,
299	(int)(mac>>16)&0xff, (int)(mac>>8)&0xff, (int)(mac>>0)&0xff);
300	}
301
302
303
304	/* fetch IP addresses */
305	inline uint32_t eth_srcIP(ethpacket_t * x)
306	{
307	if (eth_type (x) == ET_ARP) return eth_int (x->u.arp.srcIP);
308	else if (eth_type (x) == ET_IPv4)
309	return eth_int (x->u.ip.srcIP);
310	else return 0;
311	}
312	inline uint32_t eth_dstIP(ethpacket_t * x)
313	{
314	if (eth_type (x) == ET_ARP) return eth_int (x->u.arp.dstIP);
315	else if (eth_type (x) == ET_IPv4)
316	return eth_int (x->u.ip.dstIP);
317	else return 0;
318	}
319
320	inline void sprint_IPaddr (char * buf, uint32_t ip) /* char buf[16] */
321	{
322	sprintf (buf, "%d:%d:%d:%d",
323	(ip>>24)&0xff, (ip>>16)&0xff, (ip>>8)&0xff, (ip>>0)&0xff);
324	}
325
326	inline uint32_t sscan_IPaddr (char * buf)
327	{
328	unsigned int i1,i2,i3,i4;
329	if (sscanf (buf, "%d:%d:%d:%d", &i1, &i2, &i3, &i4) == 4) {
330	return (i1&0xff)<<24 \| (i2&0xff)<<16 \| (i3&0xff)<<8 \| (i4&0xff)<<0;
331	} else
332	return 0xffffffff;
333	}
334
335
336	/* fetch TCP addresses */
337	inline uint32_t eth_srcPORT(ethpacket_t * x)
338	{
339	if (eth_type (x) == ET_IPv4
340	&& eth_ipverlen (x) == 0x45
341	&& eth_ipproto (x) == IP_TCP)
342	return x->u.ip.u.tcp.srcPORT;
343	else
344	return -1;
345	}
346	inline uint32_t eth_dstPORT(ethpacket_t * x)
347	{
348	if (eth_type (x) == ET_IPv4
349	&& eth_ipverlen (x) == 0x45
350	&& eth_ipproto (x) == IP_TCP)
351	return x->u.ip.u.tcp.dstPORT;
352	else
353	return -1;
354	}
355
356
357	#if 1
358
359	const char * eth_tcp_string (int tcptype);
360
361	const char * eth_icmp_string (int icmptype, int icmpcode);
362
363
364	#else /* see "netsim.cc" */
365
366	char * eth_tcp_string (int tcptype)
367	{
368	static char buf[10];
369
370	switch (tcptype) {
371	case TCP_ECHO: return "echo";
372	case TCP_FTPDATA: return "ftpdata";
373	case TCP_FTP: return "ftp";
374	case TCP_SSH: return "ssh";
375	case TCP_TELNET: return "telnet";
376	case TCP_TIME: return "time";
377	case TCP_DNS: return "dns";
378	case TCP_HTTP: return "http";
379	case TCP_HTTPS: return "https";
380	case TCP_SUNRPC: return "sunrpc";
381	case TCP_LDAP: return "ldap";
382	case TCP_REXEC: return "rexec";
383	case TCP_RLOGIN: return "rlogin";
384	case TCP_RSHELL: return "rshell";
385	default:
386	sprintf(&buf[0], "%d", tcptype);
387	return &buf[0];
388	}
389	}
390
391	char * eth_icmp_string (int icmptype, int icmpcode)
392	{
393	static char buf[10];
394
395	switch (icmptype) {
396	case ICMP_ECHOREPLY: return "echo_reply";
397	case ICMP_UNREACHABLE:
398	switch (icmpcode) {
399	case 0: return "network_unreachable";
400	case 1: return "host_unreachable";
401	case 2: return "protocol_unreachable";
402	case 3: return "port_unreachable";
403	case 4: return "fragment_unreachable";
404	case 5: return "route_unreachable";
405	case 6: return "network_unknown";
406	case 7: return "host_unknown";
407	case 8: return "obsolete_unreachable";
408	case 9: return "network_prohibited";
409	case 10: return "host_prohibited";
410	case 11: return "network_tos_unreachable";
411	case 12: return "host_tos_unreachable";
412	default: return "unreachable_?";
413	}
414	case ICMP_SRCQUENCH: return "source_quench";
415	case ICMP_REDIRECT:
416	switch (icmpcode) {
417	case 0: return "redirect_network";
418	case 1: return "redirect_host";
419	case 2: return "redirect_tos_network";
420	case 3: return "redirect_tos_host";
421	default: return "redirect_?";
422	}
423	case ICMP_ECHO: return "echo_request";
424	case ICMP_ROUTERREPLY: return "router_reply";
425	case ICMP_ROUTERREQST: return "router_request";
426	case ICMP_TIMEOUT: return "time_exceeded";
427	case ICMP_INVARG: return "invalid_parameter";
428	case ICMP_TIMESTAMP: return "timestamp_request";
429	case ICMP_TSTAMPREPLY: return "timestamp_reply";
430	case ICMP_INFO: return "obsolete_request";
431	case ICMP_INFOREPLY: return "obsolete_reply";
432	case ICMP_MASK: return "mask_request";
433	case ICMP_MASKREPLY: return "mask_reply";
434	default:
435	sprintf(&buf[0], "%d", icmptype);
436	return &buf[0];
437	}
438	}
439
440	#endif
441
442
443	#if 0 /* see "netsim.cc"/netsim_dbgpacket() */
444	void eth_print ()
445	{
446	int et,ipt;
447	et = eth_type(&buffer.packet);
448	fprintf (stderr, "eth{%02x->%02x,%s",
449	eth_srcMAC(&buffer.packet) & 0xff,
450	eth_dstMAC(&buffer.packet) & 0xff,
451	(et == ET_IPv4 : "ip" ?
452	et == ET_ARP : "arp" ?
453	et == ET_RARP : "rarp" ? "?") );
454	switch (et) {
455	case ET_IPv4:
456	ipt = eth_ipproto(&buffer.packet);
457	fprintf (stderr, "{%d.%d->%d.%d,%s",
458	eth_srcIP(&buffer.packet) & 0xff,
459	eth_dstIP(&buffer.packet) & 0xff,
460	ipt);
461	break;
462	case ET_ARP:
463	fprintf (stderr, "{
464	break;
465	case ET_RARP:
466	break;
467	}
468	fprintf (stderr, "}\n");
469
470	}
471	#endif
472
473
474	#endif /_ETH_H/