/*
|
/*
|
* Copied from Linux Monitor (LiMon) - Networking.
|
* Copied from Linux Monitor (LiMon) - Networking.
|
*
|
*
|
* Copyright 1994 - 2000 Neil Russell.
|
* Copyright 1994 - 2000 Neil Russell.
|
* (See License)
|
* (See License)
|
* Copyright 2000 Roland Borde
|
* Copyright 2000 Roland Borde
|
* Copyright 2000 Paolo Scaffardi
|
* Copyright 2000 Paolo Scaffardi
|
* Copyright 2000, 2001 Wolfgang Denk
|
* Copyright 2000, 2001 Wolfgang Denk
|
*/
|
*/
|
|
|
/*
|
/*
|
* General Desription:
|
* General Desription:
|
*
|
*
|
* The user interface supports commands for BOOTP, RARP, and TFTP.
|
* The user interface supports commands for BOOTP, RARP, and TFTP.
|
* Also, we support ARP internally. Depending on available data,
|
* Also, we support ARP internally. Depending on available data,
|
* these interact as follows:
|
* these interact as follows:
|
*
|
*
|
* BOOTP:
|
* BOOTP:
|
*
|
*
|
* Prerequisites: - own ethernet address
|
* Prerequisites: - own ethernet address
|
* We want: - own IP address
|
* We want: - own IP address
|
* - TFTP server IP address
|
* - TFTP server IP address
|
* - name of bootfile
|
* - name of bootfile
|
* Next step: ARP
|
* Next step: ARP
|
*
|
*
|
* RARP:
|
* RARP:
|
*
|
*
|
* Prerequisites: - own ethernet address
|
* Prerequisites: - own ethernet address
|
* We want: - own IP address
|
* We want: - own IP address
|
* - TFTP server IP address
|
* - TFTP server IP address
|
* Next step: ARP
|
* Next step: ARP
|
*
|
*
|
* ARP:
|
* ARP:
|
*
|
*
|
* Prerequisites: - own ethernet address
|
* Prerequisites: - own ethernet address
|
* - own IP address
|
* - own IP address
|
* - TFTP server IP address
|
* - TFTP server IP address
|
* We want: - TFTP server ethernet address
|
* We want: - TFTP server ethernet address
|
* Next step: TFTP
|
* Next step: TFTP
|
*
|
*
|
* DHCP:
|
* DHCP:
|
*
|
*
|
* Prerequisites: - own ethernet address
|
* Prerequisites: - own ethernet address
|
* We want: - IP, Netmask, ServerIP, Gateway IP
|
* We want: - IP, Netmask, ServerIP, Gateway IP
|
* - bootfilename, lease time
|
* - bootfilename, lease time
|
* Next step: - TFTP
|
* Next step: - TFTP
|
*
|
*
|
* TFTP:
|
* TFTP:
|
*
|
*
|
* Prerequisites: - own ethernet address
|
* Prerequisites: - own ethernet address
|
* - own IP address
|
* - own IP address
|
* - TFTP server IP address
|
* - TFTP server IP address
|
* - TFTP server ethernet address
|
* - TFTP server ethernet address
|
* - name of bootfile (if unknown, we use a default name
|
* - name of bootfile (if unknown, we use a default name
|
* derived from our own IP address)
|
* derived from our own IP address)
|
* We want: - load the boot file
|
* We want: - load the boot file
|
* Next step: none
|
* Next step: none
|
*/
|
*/
|
|
|
|
|
#include "common.h"
|
#include "common.h"
|
#include "support.h"
|
#include "support.h"
|
#include "net.h"
|
#include "net.h"
|
#include "bootp.h"
|
#include "bootp.h"
|
#include "tftp.h"
|
#include "tftp.h"
|
#include "rarp.h"
|
#include "rarp.h"
|
#include "arp.h"
|
#include "arp.h"
|
#if OC_LAN==1
|
#if OC_LAN==1
|
#include "eth.h"
|
#include "eth.h"
|
#else if SMC91111_LAN==1
|
#else
|
|
# if SMC91111_LAN==1
|
#include "smc91111.h"
|
#include "smc91111.h"
|
#endif
|
#endif
|
|
#endif
|
|
|
#if 0
|
#if 0
|
#define ET_DEBUG
|
#define ET_DEBUG
|
#endif
|
#endif
|
|
|
/** BOOTP EXTENTIONS **/
|
/** BOOTP EXTENTIONS **/
|
|
|
IPaddr_t NetOurSubnetMask=0; /* Our subnet mask (0=unknown) */
|
IPaddr_t NetOurSubnetMask=0; /* Our subnet mask (0=unknown) */
|
IPaddr_t NetOurGatewayIP=0; /* Our gateways IP address */
|
IPaddr_t NetOurGatewayIP=0; /* Our gateways IP address */
|
IPaddr_t NetOurDNSIP=0; /* Our DNS IP address */
|
IPaddr_t NetOurDNSIP=0; /* Our DNS IP address */
|
char NetOurNISDomain[32]={0,}; /* Our NIS domain */
|
char NetOurNISDomain[32]={0,}; /* Our NIS domain */
|
char NetOurHostName[32]={0,}; /* Our hostname */
|
char NetOurHostName[32]={0,}; /* Our hostname */
|
char NetOurRootPath[64]={0,}; /* Our bootpath */
|
char NetOurRootPath[64]={0,}; /* Our bootpath */
|
unsigned short NetBootFileSize=0; /* Our bootfile size in blocks */
|
unsigned short NetBootFileSize=0; /* Our bootfile size in blocks */
|
|
|
/** END OF BOOTP EXTENTIONS **/
|
/** END OF BOOTP EXTENTIONS **/
|
|
|
unsigned long NetBootFileXferSize; /* The actual transferred size of the bootfile (in bytes) */
|
unsigned long NetBootFileXferSize; /* The actual transferred size of the bootfile (in bytes) */
|
unsigned char NetOurEther[6]; /* Our ethernet address */
|
unsigned char NetOurEther[6]; /* Our ethernet address */
|
unsigned char NetServerEther[6] = /* Boot server enet address */
|
unsigned char NetServerEther[6] = /* Boot server enet address */
|
{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
IPaddr_t NetOurIP; /* Our IP addr (0 = unknown) */
|
IPaddr_t NetOurIP; /* Our IP addr (0 = unknown) */
|
IPaddr_t NetServerIP; /* Our IP addr (0 = unknown) */
|
IPaddr_t NetServerIP; /* Our IP addr (0 = unknown) */
|
volatile unsigned char *NetRxPkt; /* Current receive packet */
|
volatile unsigned char *NetRxPkt; /* Current receive packet */
|
int NetRxPktLen; /* Current rx packet length */
|
int NetRxPktLen; /* Current rx packet length */
|
unsigned NetIPID; /* IP packet ID */
|
unsigned NetIPID; /* IP packet ID */
|
unsigned char NetBcastAddr[6] = /* Ethernet bcast address */
|
unsigned char NetBcastAddr[6] = /* Ethernet bcast address */
|
{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
int NetState; /* Network loop state */
|
int NetState; /* Network loop state */
|
|
|
char BootFile[128]; /* Boot File name */
|
char BootFile[128]; /* Boot File name */
|
|
|
volatile unsigned char PktBuf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN];
|
volatile unsigned char PktBuf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN];
|
|
|
volatile unsigned char *NetRxPackets[PKTBUFSRX]; /* Receive packets */
|
volatile unsigned char *NetRxPackets[PKTBUFSRX]; /* Receive packets */
|
|
|
static rxhand_f *packetHandler; /* Current RX packet handler */
|
static rxhand_f *packetHandler; /* Current RX packet handler */
|
static thand_f *timeHandler; /* Current timeout handler */
|
static thand_f *timeHandler; /* Current timeout handler */
|
static unsigned long timeValue; /* Current timeout value */
|
static unsigned long timeValue; /* Current timeout value */
|
volatile unsigned char *NetTxPacket = 0; /* THE transmit packet */
|
volatile unsigned char *NetTxPacket = 0; /* THE transmit packet */
|
|
|
static int net_check_prereq (proto_t protocol);
|
static int net_check_prereq (proto_t protocol);
|
|
|
/**********************************************************************/
|
/**********************************************************************/
|
/*
|
/*
|
* Main network processing loop.
|
* Main network processing loop.
|
*/
|
*/
|
int
|
int
|
NetLoop(proto_t protocol)
|
NetLoop(proto_t protocol)
|
{
|
{
|
#if 1
|
#if 1
|
if (!NetTxPacket) {
|
if (!NetTxPacket) {
|
int i;
|
int i;
|
printf("NetTxPacket begin setup\n");
|
printf("NetTxPacket begin setup\n");
|
/*
|
/*
|
* Setup packet buffers, aligned correctly.
|
* Setup packet buffers, aligned correctly.
|
*/
|
*/
|
NetTxPacket = &PktBuf[0] + (PKTALIGN - 1);
|
NetTxPacket = &PktBuf[0] + (PKTALIGN - 1);
|
NetTxPacket -= (unsigned long)NetTxPacket % PKTALIGN;
|
NetTxPacket -= (unsigned long)NetTxPacket % PKTALIGN;
|
for (i = 0; i < PKTBUFSRX; i++) {
|
for (i = 0; i < PKTBUFSRX; i++) {
|
NetRxPackets[i] = NetTxPacket + (i+1)*PKTSIZE_ALIGN;
|
NetRxPackets[i] = NetTxPacket + (i+1)*PKTSIZE_ALIGN;
|
}
|
}
|
}
|
}
|
|
|
eth_halt();
|
eth_halt();
|
eth_init(NetReceive);
|
eth_init(NetReceive);
|
|
|
restart:
|
restart:
|
|
|
NetCopyEther(NetOurEther, global.eth_add);
|
NetCopyEther(NetOurEther, global.eth_add);
|
|
|
NetState = NETLOOP_CONTINUE;
|
NetState = NETLOOP_CONTINUE;
|
|
|
/*
|
/*
|
* Start the ball rolling with the given start function. From
|
* Start the ball rolling with the given start function. From
|
* here on, this code is a state machine driven by received
|
* here on, this code is a state machine driven by received
|
* packets and timer events.
|
* packets and timer events.
|
*/
|
*/
|
|
|
if (protocol == TFTP) { /* TFTP */
|
if (protocol == TFTP) { /* TFTP */
|
NetOurIP = global.ip;
|
NetOurIP = global.ip;
|
NetServerIP = global.srv_ip;
|
NetServerIP = global.srv_ip;
|
NetOurGatewayIP = global.gw_ip;
|
NetOurGatewayIP = global.gw_ip;
|
NetOurSubnetMask= global.mask;
|
NetOurSubnetMask= global.mask;
|
|
|
if (net_check_prereq (protocol) != 0) {
|
if (net_check_prereq (protocol) != 0) {
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* always use ARP to get server ethernet address */
|
/* always use ARP to get server ethernet address */
|
ArpTry = 0;
|
ArpTry = 0;
|
|
|
ArpRequest ();
|
ArpRequest ();
|
|
|
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
|
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
|
} else if (protocol == DHCP) {
|
} else if (protocol == DHCP) {
|
if (net_check_prereq (protocol) != 0) {
|
if (net_check_prereq (protocol) != 0) {
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Start with a clean slate... */
|
/* Start with a clean slate... */
|
NetOurIP = 0;
|
NetOurIP = 0;
|
NetServerIP = 0;
|
NetServerIP = 0;
|
DhcpRequest(); /* Basically same as BOOTP */
|
DhcpRequest(); /* Basically same as BOOTP */
|
|
|
#endif /* CFG_CMD_DHCP */
|
#endif /* CFG_CMD_DHCP */
|
|
|
} else { /* BOOTP or RARP */
|
} else { /* BOOTP or RARP */
|
|
|
/*
|
/*
|
* initialize our IP addr to 0 in order to accept ANY
|
* initialize our IP addr to 0 in order to accept ANY
|
* IP addr assigned to us by the BOOTP / RARP server
|
* IP addr assigned to us by the BOOTP / RARP server
|
*/
|
*/
|
NetOurIP = 0;
|
NetOurIP = 0;
|
NetServerIP = 0;
|
NetServerIP = 0;
|
|
|
if (net_check_prereq (protocol) != 0) {
|
if (net_check_prereq (protocol) != 0) {
|
return 0;
|
return 0;
|
}
|
}
|
#ifdef BOOTP
|
#ifdef BOOTP
|
if (protocol == BOOTP) {
|
if (protocol == BOOTP) {
|
BootpTry = 0;
|
BootpTry = 0;
|
BootpRequest ();
|
BootpRequest ();
|
}
|
}
|
#endif
|
#endif
|
#ifdef RARP
|
#ifdef RARP
|
if {
|
if {
|
RarpTry = 0;
|
RarpTry = 0;
|
RarpRequest ();
|
RarpRequest ();
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
|
|
NetBootFileXferSize = 0;
|
NetBootFileXferSize = 0;
|
|
|
/*
|
/*
|
* Main packet reception loop. Loop receiving packets until
|
* Main packet reception loop. Loop receiving packets until
|
* someone sets `NetQuit'.
|
* someone sets `NetQuit'.
|
*/
|
*/
|
for (;;) {
|
for (;;) {
|
// WATCHDOG_RESET();
|
// WATCHDOG_RESET();
|
/*
|
/*
|
* Check the ethernet for a new packet. The ethernet
|
* Check the ethernet for a new packet. The ethernet
|
* receive routine will process it.
|
* receive routine will process it.
|
*/
|
*/
|
eth_rx();
|
eth_rx();
|
|
|
/*
|
/*
|
* Abort if ctrl-c was pressed.
|
* Abort if ctrl-c was pressed.
|
*/
|
*/
|
if (ctrlc()) {
|
if (ctrlc()) {
|
eth_halt();
|
eth_halt();
|
printf("\nAbort\n");
|
printf("\nAbort\n");
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* Check for a timeout, and run the timeout handler
|
* Check for a timeout, and run the timeout handler
|
* if we have one.
|
* if we have one.
|
*/
|
*/
|
/*
|
/*
|
if (timeHandler && (get_timer(0) > timeValue)) {
|
if (timeHandler && (get_timer(0) > timeValue)) {
|
thand_f *x;
|
thand_f *x;
|
|
|
x = timeHandler;
|
x = timeHandler;
|
timeHandler = (thand_f *)0;
|
timeHandler = (thand_f *)0;
|
(*x)();
|
(*x)();
|
}
|
}
|
*/
|
*/
|
|
|
switch (NetState) {
|
switch (NetState) {
|
|
|
case NETLOOP_RESTART:
|
case NETLOOP_RESTART:
|
goto restart;
|
goto restart;
|
|
|
case NETLOOP_SUCCESS:
|
case NETLOOP_SUCCESS:
|
if (NetBootFileXferSize > 0) {
|
if (NetBootFileXferSize > 0) {
|
printf("Bytes transferred = %ld (0x%lx)\n",
|
printf("Bytes transferred = %ld (0x%lx)\n",
|
NetBootFileXferSize,
|
NetBootFileXferSize,
|
NetBootFileXferSize);
|
NetBootFileXferSize);
|
#ifdef TFTP_CALC_CHKSUM
|
#ifdef TFTP_CALC_CHKSUM
|
printf("CHKSUM: 0x%lx\n", TFTP_CHKSUM);
|
printf("CHKSUM: 0x%lx\n", TFTP_CHKSUM);
|
#endif
|
#endif
|
}
|
}
|
eth_halt();
|
eth_halt();
|
return NetBootFileXferSize;
|
return NetBootFileXferSize;
|
|
|
case NETLOOP_FAIL:
|
case NETLOOP_FAIL:
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
|
|
/**********************************************************************/
|
/**********************************************************************/
|
|
|
|
|
#if 1
|
#if 1
|
void
|
void
|
NetStartAgain(void)
|
NetStartAgain(void)
|
{
|
{
|
NetState = NETLOOP_RESTART;
|
NetState = NETLOOP_RESTART;
|
}
|
}
|
|
|
/**********************************************************************/
|
/**********************************************************************/
|
/*
|
/*
|
* Miscelaneous bits.
|
* Miscelaneous bits.
|
*/
|
*/
|
|
|
void
|
void
|
NetSetHandler(rxhand_f * f)
|
NetSetHandler(rxhand_f * f)
|
{
|
{
|
packetHandler = f;
|
packetHandler = f;
|
}
|
}
|
|
|
|
|
void
|
void
|
NetSetTimeout(int iv, thand_f * f)
|
NetSetTimeout(int iv, thand_f * f)
|
{
|
{
|
if (iv == 0) {
|
if (iv == 0) {
|
timeHandler = (thand_f *)0;
|
timeHandler = (thand_f *)0;
|
} else {
|
} else {
|
timeHandler = f;
|
timeHandler = f;
|
timeValue = get_timer(0) + iv;
|
timeValue = get_timer(0) + iv;
|
}
|
}
|
}
|
}
|
|
|
|
|
void
|
void
|
NetSendPacket(volatile unsigned char * pkt, int len)
|
NetSendPacket(volatile unsigned char * pkt, int len)
|
{
|
{
|
|
|
#if OC_LAN==1
|
#if OC_LAN==1
|
unsigned char *p = (unsigned char *)0;
|
unsigned char *p = (unsigned char *)0;
|
while (p == (unsigned char*) 0)
|
while (p == (unsigned char*) 0)
|
p = eth_get_tx_buf();
|
p = eth_get_tx_buf();
|
|
|
memcpy(p, (void *)pkt, len);
|
memcpy(p, (void *)pkt, len);
|
eth_send(p, len);
|
eth_send(p, len);
|
#else if SMC91111_LAN==1
|
#else
|
|
# if SMC91111_LAN==1
|
eth_send(pkt, len);
|
eth_send(pkt, len);
|
#endif
|
#endif
|
|
#endif
|
}
|
}
|
|
|
|
|
|
|
void
|
void
|
NetReceive(volatile unsigned char * pkt, int len)
|
NetReceive(volatile unsigned char * pkt, int len)
|
{
|
{
|
Ethernet_t *et;
|
Ethernet_t *et;
|
IP_t *ip;
|
IP_t *ip;
|
ARP_t *arp;
|
ARP_t *arp;
|
int x;
|
int x;
|
IPaddr_t ip_to_check; // Used as a temp variable to check IP
|
IPaddr_t ip_to_check; // Used as a temp variable to check IP
|
|
|
NetRxPkt = pkt;
|
NetRxPkt = pkt;
|
NetRxPktLen = len;
|
NetRxPktLen = len;
|
et = (Ethernet_t *)pkt;
|
et = (Ethernet_t *)pkt;
|
|
|
x = SWAP16(et->et_protlen);
|
x = SWAP16(et->et_protlen);
|
|
|
if (x < 1514) {
|
if (x < 1514) {
|
/*
|
/*
|
* Got a 802 packet. Check the other protocol field.
|
* Got a 802 packet. Check the other protocol field.
|
*/
|
*/
|
x = SWAP16(et->et_prot);
|
x = SWAP16(et->et_prot);
|
ip = (IP_t *)(pkt + E802_HDR_SIZE);
|
ip = (IP_t *)(pkt + E802_HDR_SIZE);
|
len -= E802_HDR_SIZE;
|
len -= E802_HDR_SIZE;
|
} else {
|
} else {
|
ip = (IP_t *)(pkt + ETHER_HDR_SIZE);
|
ip = (IP_t *)(pkt + ETHER_HDR_SIZE);
|
len -= ETHER_HDR_SIZE;
|
len -= ETHER_HDR_SIZE;
|
}
|
}
|
|
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("Receive from protocol 0x%x\n", x);
|
printf("Receive from protocol 0x%x\n", x);
|
#endif
|
#endif
|
|
|
switch (x) {
|
switch (x) {
|
|
|
case PROT_ARP:
|
case PROT_ARP:
|
/*
|
/*
|
* We have to deal with two types of ARP packets:
|
* We have to deal with two types of ARP packets:
|
* - REQUEST packets will be answered by sending our
|
* - REQUEST packets will be answered by sending our
|
* IP address - if we know it.
|
* IP address - if we know it.
|
* - REPLY packates are expected only after we asked
|
* - REPLY packates are expected only after we asked
|
* for the TFTP server's or the gateway's ethernet
|
* for the TFTP server's or the gateway's ethernet
|
* address; so if we receive such a packet, we set
|
* address; so if we receive such a packet, we set
|
* the server ethernet address
|
* the server ethernet address
|
*/
|
*/
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("Got ARP\n");
|
printf("Got ARP\n");
|
#endif
|
#endif
|
arp = (ARP_t *)ip;
|
arp = (ARP_t *)ip;
|
if (len < ARP_HDR_SIZE) {
|
if (len < ARP_HDR_SIZE) {
|
printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
|
printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
|
return;
|
return;
|
}
|
}
|
if (SWAP16(arp->ar_hrd) != ARP_ETHER) {
|
if (SWAP16(arp->ar_hrd) != ARP_ETHER) {
|
return;
|
return;
|
}
|
}
|
if (SWAP16(arp->ar_pro) != PROT_IP) {
|
if (SWAP16(arp->ar_pro) != PROT_IP) {
|
return;
|
return;
|
}
|
}
|
if (arp->ar_hln != 6) {
|
if (arp->ar_hln != 6) {
|
return;
|
return;
|
}
|
}
|
if (arp->ar_pln != 4) {
|
if (arp->ar_pln != 4) {
|
return;
|
return;
|
}
|
}
|
|
|
memcpy((void*) &ip_to_check, (void*)&arp->ar_data[16],
|
memcpy((void*) &ip_to_check, (void*)&arp->ar_data[16],
|
sizeof(IPaddr_t));
|
sizeof(IPaddr_t));
|
if (NetOurIP == 0 ||
|
if (NetOurIP == 0 ||
|
ip_to_check != NetOurIP) {
|
ip_to_check != NetOurIP) {
|
return;
|
return;
|
}
|
}
|
|
|
switch (SWAP16(arp->ar_op)) {
|
switch (SWAP16(arp->ar_op)) {
|
case ARPOP_REQUEST: /* reply with our IP address */
|
case ARPOP_REQUEST: /* reply with our IP address */
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("Got ARP REQUEST, return our IP\n");
|
printf("Got ARP REQUEST, return our IP\n");
|
#endif
|
#endif
|
NetSetEther((unsigned char *)et, et->et_src, PROT_ARP);
|
NetSetEther((unsigned char *)et, et->et_src, PROT_ARP);
|
arp->ar_op = SWAP16(ARPOP_REPLY);
|
arp->ar_op = SWAP16(ARPOP_REPLY);
|
NetCopyEther(&arp->ar_data[10], &arp->ar_data[0]);
|
NetCopyEther(&arp->ar_data[10], &arp->ar_data[0]);
|
NetCopyEther(&arp->ar_data[0], NetOurEther);
|
NetCopyEther(&arp->ar_data[0], NetOurEther);
|
//*(IPaddr_t *)(&arp->ar_data[16]) = *(IPaddr_t *)(&arp->ar_data[6]);
|
//*(IPaddr_t *)(&arp->ar_data[16]) = *(IPaddr_t *)(&arp->ar_data[6]);
|
memcpy((void*)&arp->ar_data[16],(void*) &arp->ar_data[6],
|
memcpy((void*)&arp->ar_data[16],(void*) &arp->ar_data[6],
|
sizeof(IPaddr_t));
|
sizeof(IPaddr_t));
|
//*(IPaddr_t *)(&arp->ar_data[6]) = NetOurIP;
|
//*(IPaddr_t *)(&arp->ar_data[6]) = NetOurIP;
|
memcpy((void*)&arp->ar_data[6],(void*) &NetOurIP,
|
memcpy((void*)&arp->ar_data[6],(void*) &NetOurIP,
|
sizeof(IPaddr_t));
|
sizeof(IPaddr_t));
|
|
|
NetSendPacket((unsigned char *)et,
|
NetSendPacket((unsigned char *)et,
|
((unsigned char *)arp-pkt)+ARP_HDR_SIZE);
|
((unsigned char *)arp-pkt)+ARP_HDR_SIZE);
|
return;
|
return;
|
case ARPOP_REPLY: /* set TFTP server eth addr */
|
case ARPOP_REPLY: /* set TFTP server eth addr */
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("Got ARP REPLY, set server/gtwy eth addr\n");
|
printf("Got ARP REPLY, set server/gtwy eth addr\n");
|
#endif
|
#endif
|
NetCopyEther(NetServerEther, &arp->ar_data[0]);
|
NetCopyEther(NetServerEther, &arp->ar_data[0]);
|
(*packetHandler)(0,0,0,0); /* start TFTP */
|
(*packetHandler)(0,0,0,0); /* start TFTP */
|
return;
|
return;
|
default:
|
default:
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("Unexpected ARP opcode 0x%x\n", SWAP16(arp->ar_op));
|
printf("Unexpected ARP opcode 0x%x\n", SWAP16(arp->ar_op));
|
#endif
|
#endif
|
return;
|
return;
|
}
|
}
|
|
|
case PROT_RARP:
|
case PROT_RARP:
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("Got RARP\n");
|
printf("Got RARP\n");
|
#endif
|
#endif
|
arp = (ARP_t *)ip;
|
arp = (ARP_t *)ip;
|
if (len < ARP_HDR_SIZE) {
|
if (len < ARP_HDR_SIZE) {
|
printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
|
printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
|
return;
|
return;
|
}
|
}
|
|
|
if ((SWAP16(arp->ar_op) != RARPOP_REPLY) ||
|
if ((SWAP16(arp->ar_op) != RARPOP_REPLY) ||
|
(SWAP16(arp->ar_hrd) != ARP_ETHER) ||
|
(SWAP16(arp->ar_hrd) != ARP_ETHER) ||
|
(SWAP16(arp->ar_pro) != PROT_IP) ||
|
(SWAP16(arp->ar_pro) != PROT_IP) ||
|
(arp->ar_hln != 6) || (arp->ar_pln != 4)) {
|
(arp->ar_hln != 6) || (arp->ar_pln != 4)) {
|
|
|
printf("invalid RARP header\n");
|
printf("invalid RARP header\n");
|
} else {
|
} else {
|
//NetOurIP = *((IPaddr_t *)&arp->ar_data[16]);
|
//NetOurIP = *((IPaddr_t *)&arp->ar_data[16]);
|
memcpy((void*) &NetOurIP, (void*) &arp->ar_data[16],
|
memcpy((void*) &NetOurIP, (void*) &arp->ar_data[16],
|
sizeof(IPaddr_t));
|
sizeof(IPaddr_t));
|
//NetServerIP = *((IPaddr_t *)&arp->ar_data[6]);
|
//NetServerIP = *((IPaddr_t *)&arp->ar_data[6]);
|
memcpy((void*) &NetServerIP,(void*) &arp->ar_data[6],
|
memcpy((void*) &NetServerIP,(void*) &arp->ar_data[6],
|
sizeof(IPaddr_t));
|
sizeof(IPaddr_t));
|
|
|
NetCopyEther(NetServerEther, &arp->ar_data[0]);
|
NetCopyEther(NetServerEther, &arp->ar_data[0]);
|
|
|
(*packetHandler)(0,0,0,0);
|
(*packetHandler)(0,0,0,0);
|
}
|
}
|
break;
|
break;
|
|
|
case PROT_IP:
|
case PROT_IP:
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("Got IP\n");
|
printf("Got IP\n");
|
#endif
|
#endif
|
if (len < IP_HDR_SIZE) {
|
if (len < IP_HDR_SIZE) {
|
debug ("len bad %d < %d\n", len, IP_HDR_SIZE);
|
debug ("len bad %d < %d\n", len, IP_HDR_SIZE);
|
return;
|
return;
|
}
|
}
|
if (len < SWAP16(ip->ip_len)) {
|
if (len < SWAP16(ip->ip_len)) {
|
printf("len bad %d < %d\n", len, SWAP16(ip->ip_len));
|
printf("len bad %d < %d\n", len, SWAP16(ip->ip_len));
|
return;
|
return;
|
}
|
}
|
len = SWAP16(ip->ip_len);
|
len = SWAP16(ip->ip_len);
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("len=%d, v=%02x\n", len, ip->ip_hl_v & 0xff);
|
printf("len=%d, v=%02x\n", len, ip->ip_hl_v & 0xff);
|
#endif
|
#endif
|
if ((ip->ip_hl_v & 0xf0) != 0x40) {
|
if ((ip->ip_hl_v & 0xf0) != 0x40) {
|
return;
|
return;
|
}
|
}
|
if (ip->ip_off & SWAP16c(0x1fff)) { /* Can't deal w/ fragments */
|
if (ip->ip_off & SWAP16c(0x1fff)) { /* Can't deal w/ fragments */
|
return;
|
return;
|
}
|
}
|
if (!NetCksumOk((unsigned char *)ip, IP_HDR_SIZE_NO_UDP / 2)) {
|
if (!NetCksumOk((unsigned char *)ip, IP_HDR_SIZE_NO_UDP / 2)) {
|
//printf("checksum bad\n");
|
//printf("checksum bad\n");
|
return;
|
return;
|
}
|
}
|
|
|
memcpy((void*)&ip_to_check,(void*)&ip->ip_dst, sizeof (IPaddr_t));
|
memcpy((void*)&ip_to_check,(void*)&ip->ip_dst, sizeof (IPaddr_t));
|
|
|
if (NetOurIP &&
|
if (NetOurIP &&
|
ip_to_check != NetOurIP &&
|
ip_to_check != NetOurIP &&
|
ip_to_check != 0xFFFFFFFF) {
|
ip_to_check != 0xFFFFFFFF) {
|
return;
|
return;
|
}
|
}
|
/*
|
/*
|
* watch for ICMP host redirects
|
* watch for ICMP host redirects
|
*
|
*
|
* There is no real handler code (yet). We just watch
|
* There is no real handler code (yet). We just watch
|
* for ICMP host redirect messages. In case anybody
|
* for ICMP host redirect messages. In case anybody
|
* sees these messages: please contact me
|
* sees these messages: please contact me
|
* (wd@denx.de), or - even better - send me the
|
* (wd@denx.de), or - even better - send me the
|
* necessary fixes :-)
|
* necessary fixes :-)
|
*
|
*
|
* Note: in all cases where I have seen this so far
|
* Note: in all cases where I have seen this so far
|
* it was a problem with the router configuration,
|
* it was a problem with the router configuration,
|
* for instance when a router was configured in the
|
* for instance when a router was configured in the
|
* BOOTP reply, but the TFTP server was on the same
|
* BOOTP reply, but the TFTP server was on the same
|
* subnet. So this is probably a warning that your
|
* subnet. So this is probably a warning that your
|
* configuration might be wrong. But I'm not really
|
* configuration might be wrong. But I'm not really
|
* sure if there aren't any other situations.
|
* sure if there aren't any other situations.
|
*/
|
*/
|
if (ip->ip_p == IPPROTO_ICMP) {
|
if (ip->ip_p == IPPROTO_ICMP) {
|
ICMP_t *icmph = (ICMP_t *)&(ip->udp_src);
|
ICMP_t *icmph = (ICMP_t *)&(ip->udp_src);
|
|
|
if (icmph->type != ICMP_REDIRECT)
|
if (icmph->type != ICMP_REDIRECT)
|
return;
|
return;
|
if (icmph->code != ICMP_REDIR_HOST)
|
if (icmph->code != ICMP_REDIR_HOST)
|
return;
|
return;
|
printf (" ICMP Host Redirect to ");
|
printf (" ICMP Host Redirect to ");
|
print_IPaddr(icmph->un.gateway);
|
print_IPaddr(icmph->un.gateway);
|
putc(' ');
|
putc(' ');
|
} else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */
|
} else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */
|
return;
|
return;
|
}
|
}
|
|
|
/*
|
/*
|
* IP header OK. Pass the packet to the current handler.
|
* IP header OK. Pass the packet to the current handler.
|
*/
|
*/
|
(*packetHandler)((unsigned char *)ip +IP_HDR_SIZE,
|
(*packetHandler)((unsigned char *)ip +IP_HDR_SIZE,
|
SWAP16(ip->udp_dst),
|
SWAP16(ip->udp_dst),
|
SWAP16(ip->udp_src),
|
SWAP16(ip->udp_src),
|
SWAP16(ip->udp_len) - 8);
|
SWAP16(ip->udp_len) - 8);
|
|
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
|
|
/**********************************************************************/
|
/**********************************************************************/
|
|
|
static int net_check_prereq (proto_t protocol)
|
static int net_check_prereq (proto_t protocol)
|
{
|
{
|
switch (protocol) {
|
switch (protocol) {
|
case ARP: /* nothing to do */
|
case ARP: /* nothing to do */
|
break;
|
break;
|
|
|
case TFTP:
|
case TFTP:
|
if (NetServerIP == 0) {
|
if (NetServerIP == 0) {
|
printf ("*** ERROR: `serverip' not set\n");
|
printf ("*** ERROR: `serverip' not set\n");
|
return (1);
|
return (1);
|
}
|
}
|
|
|
if (NetOurIP == 0) {
|
if (NetOurIP == 0) {
|
printf ("*** ERROR: `ipaddr' not set\n");
|
printf ("*** ERROR: `ipaddr' not set\n");
|
return (1);
|
return (1);
|
}
|
}
|
/* Fall through */
|
/* Fall through */
|
|
|
case DHCP:
|
case DHCP:
|
case RARP:
|
case RARP:
|
case BOOTP:
|
case BOOTP:
|
if (memcmp(NetOurEther, "\0\0\0\0\0\0", 6) == 0) {
|
if (memcmp(NetOurEther, "\0\0\0\0\0\0", 6) == 0) {
|
printf ("*** ERROR: `ethaddr' not set\n");
|
printf ("*** ERROR: `ethaddr' not set\n");
|
return (1);
|
return (1);
|
}
|
}
|
/* Fall through */
|
/* Fall through */
|
}
|
}
|
return (0); /* OK */
|
return (0); /* OK */
|
}
|
}
|
/**********************************************************************/
|
/**********************************************************************/
|
|
|
int
|
int
|
NetCksumOk(unsigned char * ptr, int len)
|
NetCksumOk(unsigned char * ptr, int len)
|
{
|
{
|
return !((NetCksum(ptr, len) + 1) & 0xfffe);
|
return !((NetCksum(ptr, len) + 1) & 0xfffe);
|
}
|
}
|
|
|
|
|
unsigned
|
unsigned
|
NetCksum(unsigned char * ptr, int len)
|
NetCksum(unsigned char * ptr, int len)
|
{
|
{
|
unsigned long xsum;
|
unsigned long xsum;
|
|
|
xsum = 0;
|
xsum = 0;
|
while (len-- > 0)
|
while (len-- > 0)
|
{
|
{
|
xsum += (*((unsigned short *)ptr));
|
xsum += (*((unsigned short *)ptr));
|
ptr += sizeof(short);
|
ptr += sizeof(short);
|
}
|
}
|
|
|
xsum = (xsum & 0xffff) + (xsum >> 16);
|
xsum = (xsum & 0xffff) + (xsum >> 16);
|
xsum = (xsum & 0xffff) + (xsum >> 16);
|
xsum = (xsum & 0xffff) + (xsum >> 16);
|
return (xsum & 0xffff);
|
return (xsum & 0xffff);
|
}
|
}
|
|
|
|
|
void
|
void
|
NetCopyEther(volatile unsigned char * to, unsigned char * from)
|
NetCopyEther(volatile unsigned char * to, unsigned char * from)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < 6; i++)
|
for (i = 0; i < 6; i++)
|
*to++ = *from++;
|
*to++ = *from++;
|
}
|
}
|
|
|
|
|
void
|
void
|
NetSetEther(volatile unsigned char * xet, unsigned char * addr, unsigned long prot)
|
NetSetEther(volatile unsigned char * xet, unsigned char * addr, unsigned long prot)
|
{
|
{
|
volatile Ethernet_t *et = (Ethernet_t *)xet;
|
volatile Ethernet_t *et = (Ethernet_t *)xet;
|
|
|
NetCopyEther(et->et_dest, addr);
|
NetCopyEther(et->et_dest, addr);
|
NetCopyEther(et->et_src, NetOurEther);
|
NetCopyEther(et->et_src, NetOurEther);
|
et->et_protlen = SWAP16(prot);
|
et->et_protlen = SWAP16(prot);
|
}
|
}
|
|
|
|
|
void
|
void
|
NetSetIP(volatile unsigned char * xip, IPaddr_t dest, int dport, int sport, int len)
|
NetSetIP(volatile unsigned char * xip, IPaddr_t dest, int dport, int sport, int len)
|
{
|
{
|
volatile IP_t *ip = (IP_t *)xip;
|
volatile IP_t *ip = (IP_t *)xip;
|
|
|
/*
|
/*
|
* If the data is an odd number of bytes, zero the
|
* If the data is an odd number of bytes, zero the
|
* byte after the last byte so that the checksum
|
* byte after the last byte so that the checksum
|
* will work.
|
* will work.
|
*/
|
*/
|
if (len & 1)
|
if (len & 1)
|
xip[IP_HDR_SIZE + len] = 0;
|
xip[IP_HDR_SIZE + len] = 0;
|
|
|
/*
|
/*
|
* Construct an IP and UDP header.
|
* Construct an IP and UDP header.
|
(need to set no fragment bit - XXX)
|
(need to set no fragment bit - XXX)
|
*/
|
*/
|
ip->ip_hl_v = 0x45; /* IP_HDR_SIZE / 4 (not including UDP) */
|
ip->ip_hl_v = 0x45; /* IP_HDR_SIZE / 4 (not including UDP) */
|
ip->ip_tos = 0;
|
ip->ip_tos = 0;
|
ip->ip_len = SWAP16(IP_HDR_SIZE + len);
|
ip->ip_len = SWAP16(IP_HDR_SIZE + len);
|
ip->ip_id = SWAP16(NetIPID++);
|
ip->ip_id = SWAP16(NetIPID++);
|
ip->ip_off = SWAP16c(0x4000); /* No fragmentation */
|
ip->ip_off = SWAP16c(0x4000); /* No fragmentation */
|
ip->ip_ttl = 255;
|
ip->ip_ttl = 255;
|
ip->ip_p = 17; /* UDP */
|
ip->ip_p = 17; /* UDP */
|
ip->ip_sum = 0;
|
ip->ip_sum = 0;
|
//ip->ip_src = NetOurIP;
|
//ip->ip_src = NetOurIP;
|
memcpy((void*)&ip->ip_src,(void*) &NetOurIP,
|
memcpy((void*)&ip->ip_src,(void*) &NetOurIP,
|
sizeof(IPaddr_t));
|
sizeof(IPaddr_t));
|
//ip->ip_dst = dest;
|
//ip->ip_dst = dest;
|
memcpy((void*)&ip->ip_dst,(void*) &dest,
|
memcpy((void*)&ip->ip_dst,(void*) &dest,
|
sizeof(IPaddr_t));
|
sizeof(IPaddr_t));
|
ip->udp_src = SWAP16(sport);
|
ip->udp_src = SWAP16(sport);
|
ip->udp_dst = SWAP16(dport);
|
ip->udp_dst = SWAP16(dport);
|
ip->udp_len = SWAP16(8 + len);
|
ip->udp_len = SWAP16(8 + len);
|
ip->udp_xsum = 0;
|
ip->udp_xsum = 0;
|
ip->ip_sum = ~NetCksum((unsigned char *)ip, IP_HDR_SIZE_NO_UDP / 2);
|
ip->ip_sum = ~NetCksum((unsigned char *)ip, IP_HDR_SIZE_NO_UDP / 2);
|
}
|
}
|
|
|
void copy_filename (unsigned char *dst, unsigned char *src, int size)
|
void copy_filename (unsigned char *dst, unsigned char *src, int size)
|
{
|
{
|
if (*src && (*src == '"')) {
|
if (*src && (*src == '"')) {
|
++src;
|
++src;
|
--size;
|
--size;
|
}
|
}
|
|
|
while ((--size > 0) && *src && (*src != '"')) {
|
while ((--size > 0) && *src && (*src != '"')) {
|
*dst++ = *src++;
|
*dst++ = *src++;
|
}
|
}
|
*dst = '\0';
|
*dst = '\0';
|
}
|
}
|
|
|
void ip_to_string (IPaddr_t x, char *s)
|
void ip_to_string (IPaddr_t x, char *s)
|
{
|
{
|
char num[] = "0123456789ABCDEF";
|
char num[] = "0123456789ABCDEF";
|
int i;
|
int i;
|
|
|
x = SWAP32(x);
|
x = SWAP32(x);
|
|
|
for(i = 28; i >= 0; i -= 4)
|
for(i = 28; i >= 0; i -= 4)
|
*s++ = num[((x >> i) & 0x0f)];
|
*s++ = num[((x >> i) & 0x0f)];
|
*s = 0;
|
*s = 0;
|
}
|
}
|
|
|
void print_IPaddr (IPaddr_t x)
|
void print_IPaddr (IPaddr_t x)
|
{
|
{
|
char tmp[12];
|
char tmp[12];
|
|
|
ip_to_string(x, tmp);
|
ip_to_string(x, tmp);
|
|
|
printf(tmp);
|
printf(tmp);
|
}
|
}
|
|
|
static unsigned int i2a(char* dest,unsigned int x) {
|
static unsigned int i2a(char* dest,unsigned int x) {
|
register unsigned int tmp=x;
|
register unsigned int tmp=x;
|
register unsigned int len=0;
|
register unsigned int len=0;
|
if (x>=100) { *dest++=tmp/100+'0'; tmp=tmp%100; ++len; }
|
if (x>=100) { *dest++=tmp/100+'0'; tmp=tmp%100; ++len; }
|
if (x>=10) { *dest++=tmp/10+'0'; tmp=tmp%10; ++len; }
|
if (x>=10) { *dest++=tmp/10+'0'; tmp=tmp%10; ++len; }
|
*dest++=tmp+'0';
|
*dest++=tmp+'0';
|
return len+1;
|
return len+1;
|
}
|
}
|
|
|
char *inet_ntoa(unsigned long in) {
|
char *inet_ntoa(unsigned long in) {
|
static char buf[20];
|
static char buf[20];
|
unsigned int len;
|
unsigned int len;
|
unsigned char *ip=(unsigned char*)∈
|
unsigned char *ip=(unsigned char*)∈
|
|
|
len=i2a(buf,ip[0]); buf[len]='.'; ++len;
|
len=i2a(buf,ip[0]); buf[len]='.'; ++len;
|
len+=i2a(buf+ len,ip[1]); buf[len]='.'; ++len;
|
len+=i2a(buf+ len,ip[1]); buf[len]='.'; ++len;
|
len+=i2a(buf+ len,ip[2]); buf[len]='.'; ++len;
|
len+=i2a(buf+ len,ip[2]); buf[len]='.'; ++len;
|
len+=i2a(buf+ len,ip[3]); buf[len]=0;
|
len+=i2a(buf+ len,ip[3]); buf[len]=0;
|
return buf;
|
return buf;
|
}
|
}
|
|
|
unsigned long inet_aton(const char *cp)
|
unsigned long inet_aton(const char *cp)
|
{
|
{
|
unsigned long a[4];
|
unsigned long a[4];
|
unsigned long ret;
|
unsigned long ret;
|
char *p = (char *)cp;
|
char *p = (char *)cp;
|
int i,d;
|
int i,d;
|
if (strcmp(cp, "255.255.255.255") == 0)
|
if (strcmp(cp, "255.255.255.255") == 0)
|
return -1;
|
return -1;
|
|
|
for(i = 0; i < 4; i++) {
|
for(i = 0; i < 4; i++) {
|
a[i] = strtoul(p, 0, 0);
|
a[i] = strtoul(p, 0, 0);
|
for(d=1; (p[d] != '.') && (i < 3); d++);
|
for(d=1; (p[d] != '.') && (i < 3); d++);
|
p = &p[d+1];
|
p = &p[d+1];
|
}
|
}
|
|
|
ret = (a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3];
|
ret = (a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3];
|
return ret;
|
return ret;
|
}
|
}
|
|
|
#endif
|
#endif
|
|
|
