/**************************************************************************
RPC_LOOKUP - Lookup RPC Port numbers
**************************************************************************/
static void
rpc_req (int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
{
struct rpc_t pkt;
unsigned long id;
uint32_t *p;
int pktlen;
int sport;
id = ++rpc_id;
pkt.u.call.id = htonl(id);
pkt.u.call.type = htonl(MSG_CALL);
pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
pkt.u.call.prog = htonl(rpc_prog);
pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
pkt.u.call.proc = htonl(rpc_proc);
p = (uint32_t *)&(pkt.u.call.data);
if (datalen)
memcpy ((char *)p, (char *)data, datalen*sizeof(uint32_t));
pktlen = (char *)p + datalen*sizeof(uint32_t) - (char *)&pkt;
memcpy ((char *)NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE, (char *)&pkt, pktlen);
if (rpc_prog == PROG_PORTMAP)
sport = SUNRPC_PORT;
else if (rpc_prog == PROG_MOUNT)
sport = NfsSrvMountPort;
else
sport = NfsSrvNfsPort;
NetSendUDPPacket (NetServerEther, NfsServerIP, sport, NfsOurPort, pktlen);
}
static void
DnsSend(void)
{
struct header *header;
int n, name_len;
uchar *p, *pkt;
const char *s;
const char *name;
enum dns_query_type qtype = DNS_A_RECORD;
name = NetDNSResolve;
pkt = p = (uchar *)(NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE);
/* Prepare DNS packet header */
header = (struct header *) pkt;
header->tid = 1;
header->flags = htons(0x100); /* standard query */
header->nqueries = htons(1); /* Just one query */
header->nanswers = 0;
header->nauth = 0;
header->nother = 0;
/* Encode DNS name */
name_len = strlen(name);
p = (uchar *) &header->data; /* For encoding host name into packet */
do {
s = strchr(name, '.');
if (!s)
s = name + name_len;
n = s - name; /* Chunk length */
*p++ = n; /* Copy length */
memcpy(p, name, n); /* Copy chunk */
p += n;
if (*s == '.')
n++;
name += n;
name_len -= n;
} while (*s != '\0');
*p++ = 0; /* Mark end of host name */
*p++ = 0; /* Some servers require double null */
*p++ = (unsigned char) qtype; /* Query Type */
*p++ = 0;
*p++ = 1; /* Class: inet, 0x0001 */
n = p - pkt; /* Total packet length */
debug("Packet size %d\n", n);
DnsOurPort = random_port();
NetSendUDPPacket(NetServerEther, NetOurDNSIP, DNS_SERVICE_PORT,
DnsOurPort, n);
debug("DNS packet sent\n");
}
void NcStart (void)
{
if (!output_packet_len || memcmp (nc_ether, NetEtherNullAddr, 6)) {
/* going to check for input packet */
NetSetHandler (nc_handler);
NetSetTimeout (net_timeout, nc_timeout);
} else {
/* send arp request */
uchar *pkt;
NetSetHandler (nc_wait_arp_handler);
pkt = (uchar *) NetTxPacket + NetEthHdrSize () + IP_HDR_SIZE;
memcpy (pkt, output_packet, output_packet_len);
NetSendUDPPacket (nc_ether, nc_ip, nc_port, nc_port, output_packet_len);
}
}
static void
SntpSend (void)
{
struct sntp_pkt_t pkt;
int pktlen = SNTP_PACKET_LEN;
int sport;
debug ("%s\n", __FUNCTION__);
memset (&pkt, 0, sizeof(pkt));
pkt.li = NTP_LI_NOLEAP;
pkt.vn = NTP_VERSION;
pkt.mode = NTP_MODE_CLIENT;
memcpy ((char *)NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE, (char *)&pkt, pktlen);
SntpOurPort = 10000 + (get_timer(0) % 4096);
sport = NTP_SERVICE_PORT;
NetSendUDPPacket (NetServerEther, NetNtpServerIP, sport, SntpOurPort, pktlen);
}
static void nc_send_packet (const char *buf, int len)
{
DECLARE_GLOBAL_DATA_PTR;
struct eth_device *eth;
int inited = 0;
uchar *pkt;
uchar *ether;
IPaddr_t ip;
if ((eth = eth_get_dev ()) == NULL) {
return;
}
if (!memcmp (nc_ether, NetEtherNullAddr, 6)) {
if (eth->state == ETH_STATE_ACTIVE)
return; /* inside net loop */
output_packet = buf;
output_packet_len = len;
NetLoop (NETCONS); /* wait for arp reply and send packet */
output_packet_len = 0;
return;
}
if (eth->state != ETH_STATE_ACTIVE) {
if (eth_init (gd->bd) < 0)
return;
inited = 1;
}
pkt = (uchar *) NetTxPacket + NetEthHdrSize () + IP_HDR_SIZE;
memcpy (pkt, buf, len);
ether = nc_ether;
ip = nc_ip;
NetSendUDPPacket (ether, ip, nc_port, nc_port, len);
if (inited)
eth_halt ();
}
void BootmeStart(void)
{
if (bootme_state != BOOTME_DOWNLOAD)
check_net_config();
if (output_packet_len == 0 ||
memcmp(bootme_ether, NetEtherNullAddr, ETH_ALEN) != 0) {
/* wait for incoming packet */
net_set_udp_handler(bootme_handler);
bootme_timed_out = 0;
NetSetTimeout(bootme_timeout, bootme_timeout_handler);
} else {
/* send ARP request */
uchar *pkt;
net_set_arp_handler(bootme_wait_arp_handler);
assert(NetTxPacket != NULL);
pkt = (uchar *)NetTxPacket + NetEthHdrSize() + IP_UDP_HDR_SIZE;
memcpy(pkt, output_packet, output_packet_len);
NetSendUDPPacket(bootme_ether, bootme_ip, bootme_dst_port,
bootme_src_port, output_packet_len);
}
}
static void TftpSend(void){
volatile uchar *pkt;
volatile uchar *xp;
int len = 0;
volatile ushort *s;
/*
* We will always be sending some sort of packet, so
* cobble together the packet headers now.
*/
pkt = NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE;
switch(TftpState){
case STATE_RRQ:
xp = pkt;
s = (ushort *)pkt;
*s++ = htons(TFTP_RRQ);
pkt = (uchar *)s;
strcpy ((char *)pkt, tftp_filename);
pkt += strlen(tftp_filename) + 1;
strcpy ((char *)pkt, "octet");
pkt += 5 /*strlen("octet")*/ + 1;
strcpy ((char *)pkt, "timeout");
pkt += 7 /*strlen("timeout")*/ + 1;
sprintf((char *)pkt, "%d", TIMEOUT);
#ifdef ET_DEBUG
printf("send option \"timeout %s\"\n", (char *)pkt);
#endif
pkt += strlen((char *)pkt) + 1;
len = pkt - xp;
break;
case STATE_DATA:
case STATE_OACK:
xp = pkt;
s = (ushort *)pkt;
*s++ = htons(TFTP_ACK);
*s++ = htons(TftpBlock);
pkt = (uchar *)s;
len = pkt - xp;
break;
case STATE_TOO_LARGE:
xp = pkt;
s = (ushort *)pkt;
*s++ = htons(TFTP_ERROR);
*s++ = htons(3);
pkt = (uchar *)s;
strcpy((char *)pkt, "File too large");
pkt += 14 /*strlen("File too large")*/ + 1;
len = pkt - xp;
break;
case STATE_BAD_MAGIC:
xp = pkt;
s = (ushort *)pkt;
*s++ = htons(TFTP_ERROR);
*s++ = htons(2);
pkt = (uchar *)s;
strcpy((char *)pkt, "File has bad magic");
pkt += 18 /*strlen("File has bad magic")*/ + 1;
len = pkt - xp;
break;
}
NetSendUDPPacket(NetServerEther, NetServerIP, TftpServerPort, TftpOurPort, len);
}
static void
TftpSend(void)
{
uchar *pkt;
uchar *xp;
int len = 0;
ushort *s;
#ifdef CONFIG_MCAST_TFTP
/* Multicast TFTP.. non-MasterClients do not ACK data. */
if (Multicast
&& (TftpState == STATE_DATA)
&& (MasterClient == 0))
return;
#endif
/*
* We will always be sending some sort of packet, so
* cobble together the packet headers now.
*/
pkt = NetTxPacket + NetEthHdrSize() + IP_UDP_HDR_SIZE;
switch (TftpState) {
case STATE_SEND_RRQ:
case STATE_SEND_WRQ:
xp = pkt;
s = (ushort *)pkt;
#ifdef CONFIG_CMD_TFTPPUT
*s++ = htons(TftpState == STATE_SEND_RRQ ? TFTP_RRQ :
TFTP_WRQ);
#else
*s++ = htons(TFTP_RRQ);
#endif
pkt = (uchar *)s;
strcpy((char *)pkt, tftp_filename);
pkt += strlen(tftp_filename) + 1;
strcpy((char *)pkt, "octet");
pkt += 5 /*strlen("octet")*/ + 1;
strcpy((char *)pkt, "timeout");
pkt += 7 /*strlen("timeout")*/ + 1;
sprintf((char *)pkt, "%lu", TftpTimeoutMSecs / 1000);
debug("send option \"timeout %s\"\n", (char *)pkt);
pkt += strlen((char *)pkt) + 1;
#ifdef CONFIG_TFTP_TSIZE
pkt += sprintf((char *)pkt, "tsize%c%lu%c",
0, NetBootFileXferSize, 0);
#endif
/* try for more effic. blk size */
pkt += sprintf((char *)pkt, "blksize%c%d%c",
0, TftpBlkSizeOption, 0);
#ifdef CONFIG_MCAST_TFTP
/* Check all preconditions before even trying the option */
if (!ProhibitMcast) {
Bitmap = malloc(Mapsize);
if (Bitmap && eth_get_dev()->mcast) {
free(Bitmap);
Bitmap = NULL;
pkt += sprintf((char *)pkt, "multicast%c%c",
0, 0);
}
}
#endif /* CONFIG_MCAST_TFTP */
len = pkt - xp;
break;
case STATE_OACK:
#ifdef CONFIG_MCAST_TFTP
/* My turn! Start at where I need blocks I missed.*/
if (Multicast)
TftpBlock = ext2_find_next_zero_bit(Bitmap,
(Mapsize*8), 0);
/*..falling..*/
#endif
case STATE_RECV_WRQ:
case STATE_DATA:
xp = pkt;
s = (ushort *)pkt;
s[0] = htons(TFTP_ACK);
s[1] = htons(TftpBlock);
pkt = (uchar *)(s + 2);
#ifdef CONFIG_CMD_TFTPPUT
if (TftpWriting) {
int toload = TftpBlkSize;
int loaded = load_block(TftpBlock, pkt, toload);
s[0] = htons(TFTP_DATA);
pkt += loaded;
TftpFinalBlock = (loaded < toload);
}
#endif
len = pkt - xp;
break;
case STATE_TOO_LARGE:
xp = pkt;
s = (ushort *)pkt;
*s++ = htons(TFTP_ERROR);
*s++ = htons(3);
pkt = (uchar *)s;
strcpy((char *)pkt, "File too large");
pkt += 14 /*strlen("File too large")*/ + 1;
len = pkt - xp;
break;
case STATE_BAD_MAGIC:
xp = pkt;
s = (ushort *)pkt;
*s++ = htons(TFTP_ERROR);
*s++ = htons(2);
pkt = (uchar *)s;
strcpy((char *)pkt, "File has bad magic");
pkt += 18 /*strlen("File has bad magic")*/ + 1;
len = pkt - xp;
break;
}
NetSendUDPPacket(NetServerEther, TftpRemoteIP, TftpRemotePort,
TftpOurPort, len);
}
static void
TftpSend (void)
{
volatile uchar * pkt;
volatile uchar * xp;
int len = 0;
volatile ushort *s;
#ifdef CONFIG_MCAST_TFTP
/* Multicast TFTP.. non-MasterClients do not ACK data. */
if (Multicast
&& (TftpState == STATE_DATA)
&& (MasterClient == 0))
return;
#endif
/*
* We will always be sending some sort of packet, so
* cobble together the packet headers now.
*/
pkt = NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE;
switch (TftpState) {
case STATE_RRQ:
xp = pkt;
s = (ushort *)pkt;
*s++ = htons(TFTP_RRQ);
pkt = (uchar *)s;
strcpy ((char *)pkt, tftp_filename);
pkt += strlen(tftp_filename) + 1;
strcpy ((char *)pkt, "octet");
pkt += 5 /*strlen("octet")*/ + 1;
strcpy ((char *)pkt, "timeout");
pkt += 7 /*strlen("timeout")*/ + 1;
sprintf((char *)pkt, "%lu", TIMEOUT / 1000);
debug("send option \"timeout %s\"\n", (char *)pkt);
pkt += strlen((char *)pkt) + 1;
/* try for more effic. blk size */
pkt += sprintf((char *)pkt,"blksize%c%d%c",
0,TftpBlkSizeOption,0);
#ifdef CONFIG_MCAST_TFTP
/* Check all preconditions before even trying the option */
if (!ProhibitMcast
&& (Bitmap=malloc(Mapsize))
&& eth_get_dev()->mcast) {
free(Bitmap);
Bitmap=NULL;
pkt += sprintf((char *)pkt,"multicast%c%c",0,0);
}
#endif /* CONFIG_MCAST_TFTP */
len = pkt - xp;
break;
case STATE_OACK:
#ifdef CONFIG_MCAST_TFTP
/* My turn! Start at where I need blocks I missed.*/
if (Multicast)
TftpBlock=ext2_find_next_zero_bit(Bitmap,(Mapsize*8),0);
/*..falling..*/
#endif
case STATE_DATA:
xp = pkt;
s = (ushort *)pkt;
*s++ = htons(TFTP_ACK);
*s++ = htons(TftpBlock);
pkt = (uchar *)s;
len = pkt - xp;
break;
case STATE_TOO_LARGE:
xp = pkt;
s = (ushort *)pkt;
*s++ = htons(TFTP_ERROR);
*s++ = htons(3);
pkt = (uchar *)s;
strcpy ((char *)pkt, "File too large");
pkt += 14 /*strlen("File too large")*/ + 1;
len = pkt - xp;
break;
case STATE_BAD_MAGIC:
xp = pkt;
s = (ushort *)pkt;
*s++ = htons(TFTP_ERROR);
*s++ = htons(2);
pkt = (uchar *)s;
strcpy ((char *)pkt, "File has bad magic");
pkt += 18 /*strlen("File has bad magic")*/ + 1;
len = pkt - xp;
break;
}
NetSendUDPPacket(NetServerEther, TftpServerIP, TftpServerPort, TftpOurPort, len);
}
int bootme_send_frame(const void *buf, size_t len)
{
int ret;
struct eth_device *eth;
int inited = 0;
uchar *pkt;
eth = eth_get_dev();
if (eth == NULL)
return -EINVAL;
if (bootme_state == BOOTME_INIT)
check_net_config();
debug("%s: buf: %p len: %u from %pI4:%d to %pI4:%d\n",
__func__, buf, len, &NetOurIP, bootme_src_port, &bootme_ip, bootme_dst_port);
if (memcmp(bootme_ether, NetEtherNullAddr, ETH_ALEN) == 0) {
if (eth->state == ETH_STATE_ACTIVE)
return 0; /* inside net loop */
output_packet = buf;
output_packet_len = len;
/* wait for arp reply and send packet */
ret = NetLoop(BOOTME);
if (ret < 0) {
/* drop packet */
output_packet_len = 0;
return ret;
}
if (bootme_timed_out)
return -ETIMEDOUT;
return 0;
}
if (eth->state != ETH_STATE_ACTIVE) {
if (eth_is_on_demand_init()) {
ret = eth_init(gd->bd);
if (ret < 0)
return ret;
eth_set_last_protocol(BOOTME);
} else {
eth_init_state_only(gd->bd);
}
inited = 1;
}
assert(NetTxPacket != NULL);
pkt = (uchar *)NetTxPacket + NetEthHdrSize() + IP_UDP_HDR_SIZE;
memcpy(pkt, buf, len);
ret = NetSendUDPPacket(bootme_ether, bootme_ip, bootme_dst_port,
bootme_src_port, len);
if (inited) {
debug("Stopping network\n");
if (eth_is_on_demand_init())
eth_halt();
else
eth_halt_state_only();
}
return ret;
}
static void TftpdSend(void)
{
volatile uchar *pkt;
volatile uchar *xp;
int len = 0;
/*
* We will always be sending some sort of packet, so
* cobble together the packet headers now.
*/
pkt = NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE;
switch (TftpState)
{
case STATE_RRQ:
xp = pkt;
*((ushort *)pkt)++ = htons(TFTP_DATA);
*((ushort *)pkt)++ = htons(TftpBlock);/*fullfill the data part*/
len = pkt - xp;
break;
case STATE_WRQ:
xp = pkt;
*((ushort *)pkt)++ = htons(TFTP_ACK);
*((ushort *)pkt)++ = htons(TftpBlock);
len = pkt - xp;
break;
#ifdef ET_DEBUG
printf("send option \"timeout %s\"\n", (char *)pkt);
#endif
pkt += strlen((char *)pkt) + 1;
len = pkt - xp;
break;
case STATE_DATA:
xp = pkt;
*((ushort *)pkt)++ = htons(TFTP_ACK);
*((ushort *)pkt)++ = htons(TftpBlock);
len = pkt - xp;
break;
case STATE_FINISHACK:
xp = pkt;
*((ushort *)pkt)++ = htons(TFTP_FINISHACK);
*((ushort *)pkt)++ = htons(RescueAckFlag);
len = pkt - xp;
break;
case STATE_TOO_LARGE:
xp = pkt;
*((ushort *)pkt)++ = htons(TFTP_ERROR);
*((ushort *)pkt)++ = htons(3);
strcpy((char *)pkt, "File too large");
pkt += 14 /*strlen("File too large")*/ + 1;
len = pkt - xp;
break;
case STATE_BAD_MAGIC:
xp = pkt;
*((ushort *)pkt)++ = htons(TFTP_ERROR);
*((ushort *)pkt)++ = htons(2);
strcpy((char *)pkt, "File has bad magic");
pkt += 18 /*strlen("File has bad magic")*/ + 1;
len = pkt - xp;
break;
}
NetSendUDPPacket(NetServerEther, NetServerIP, TftpServerPort, TftpOurPort, len);
}