Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

net: cosmetic: Clean up TFTP variables and functions

Browse Source 
Make a thorough pass through all variables and function names contained
within tftp and remove CamelCase and improve naming.

Signed-off-by: Joe Hershberger <joe.hershberger@ni.com>
Acked-by: Simon Glass <sjg@chromium.org>
master
Joe Hershberger 10 years ago committed by Simon Glass
parent 1fd92db83d
commit 8885c5fe90
4 changed files with 259 additions and 254 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 16
      common/update.c
  2. 6
      net/net.c
  3. 483
      net/tftp.c
  4. 8
      net/tftp.h

16
common/update.c
Unescape View File

@ -39,8 +39,8 @@
#define CONFIG_UPDATE_TFTP_CNT_MAX 0
#endif
extern ulong TftpRRQTimeoutMSecs;
extern int TftpRRQTimeoutCountMax;
extern ulong tftp_timeout_ms;
extern int tftp_timeout_count_max;
extern flash_info_t flash_info[];
extern ulong load_addr;
@ -55,14 +55,14 @@ static int update_load(char *filename, ulong msec_max, int cnt_max, ulong addr)
rv = 0;
/* save used globals and env variable */
saved_timeout_msecs = TftpRRQTimeoutMSecs;
saved_timeout_count = TftpRRQTimeoutCountMax;
saved_timeout_msecs = tftp_timeout_ms;
saved_timeout_count = tftp_timeout_count_max;
saved_netretry = strdup(getenv("netretry"));
saved_bootfile = strdup(net_boot_file_name);
/* set timeouts for auto-update */
TftpRRQTimeoutMSecs = msec_max;
TftpRRQTimeoutCountMax = cnt_max;
tftp_timeout_ms = msec_max;
tftp_timeout_count_max = cnt_max;
/* we don't want to retry the connection if errors occur */
setenv("netretry", "no");
@ -78,8 +78,8 @@ static int update_load(char *filename, ulong msec_max, int cnt_max, ulong addr)
flush_cache(addr, size);
/* restore changed globals and env variable */
TftpRRQTimeoutMSecs = saved_timeout_msecs;
TftpRRQTimeoutCountMax = saved_timeout_count;
tftp_timeout_ms = saved_timeout_msecs;
tftp_timeout_count_max = saved_timeout_count;
setenv("netretry", saved_netretry);
if (saved_netretry != NULL)

6
net/net.c
Unescape View File

@ -247,7 +247,7 @@ void net_auto_load(void)
net_set_state(NETLOOP_SUCCESS);
return;
}
TftpStart(TFTPGET);
tftp_start(TFTPGET);
}
static void NetInitLoop(void)
@ -372,11 +372,11 @@ restart:
case TFTPPUT:
#endif
/* always use ARP to get server ethernet address */
TftpStart(protocol);
tftp_start(protocol);
break;
#ifdef CONFIG_CMD_TFTPSRV
case TFTPSRV:
TftpStartServer();
tftp_start_server();
break;
#endif
#if defined(CONFIG_CMD_DHCP)

483
net/tftp.c
Unescape View File

@ -39,21 +39,21 @@
#define TFTP_ERROR 5
#define TFTP_OACK 6
static ulong TftpTimeoutMSecs = TIMEOUT;
static int TftpTimeoutCountMax = TIMEOUT_COUNT;
static ulong timeout_ms = TIMEOUT;
static int timeout_count_max = TIMEOUT_COUNT;
static ulong time_start; /* Record time we started tftp */
/*
* These globals govern the timeout behavior when attempting a connection to a
* TFTP server. TftpRRQTimeoutMSecs specifies the number of milliseconds to
* TFTP server. tftp_timeout_ms specifies the number of milliseconds to
* wait for the server to respond to initial connection. Second global,
* TftpRRQTimeoutCountMax, gives the number of such connection retries.
* TftpRRQTimeoutCountMax must be non-negative and TftpRRQTimeoutMSecs must be
* tftp_timeout_count_max, gives the number of such connection retries.
* tftp_timeout_count_max must be non-negative and tftp_timeout_ms must be
* positive. The globals are meant to be set (and restored) by code needing
* non-standard timeout behavior when initiating a TFTP transfer.
*/
ulong TftpRRQTimeoutMSecs = TIMEOUT;
int TftpRRQTimeoutCountMax = TIMEOUT_COUNT;
ulong tftp_timeout_ms = TIMEOUT;
int tftp_timeout_count_max = TIMEOUT_COUNT;
enum {
TFTP_ERR_UNDEFINED = 0,
@ -67,30 +67,32 @@ enum {
static struct in_addr tftp_remote_ip;
/* The UDP port at their end */
static int TftpRemotePort;
static int tftp_remote_port;
/* The UDP port at our end */
static int TftpOurPort;
static int TftpTimeoutCount;
static int tftp_our_port;
static int timeout_count;
/* packet sequence number */
static ulong TftpBlock;
static ulong tftp_cur_block;
/* last packet sequence number received */
static ulong TftpLastBlock;
static ulong tftp_prev_block;
/* count of sequence number wraparounds */
static ulong TftpBlockWrap;
static ulong tftp_block_wrap;
/* memory offset due to wrapping */
static ulong TftpBlockWrapOffset;
static int TftpState;
static ulong tftp_block_wrap_offset;
static int tftp_state;
#ifdef CONFIG_TFTP_TSIZE
/* The file size reported by the server */
static int TftpTsize;
static int tftp_tsize;
/* The number of hashes we printed */
static short TftpNumchars;
static short tftp_tsize_num_hash;
#endif
#ifdef CONFIG_CMD_TFTPPUT
static int TftpWriting; /* 1 if writing, else 0 */
static int TftpFinalBlock; /* 1 if we have sent the last block */
/* 1 if writing, else 0 */
static int tftp_put_active;
/* 1 if we have sent the last block */
static int tftp_put_final_block_sent;
#else
#define TftpWriting 0
#define tftp_put_active 0
#endif
#define STATE_SEND_RRQ 1
@ -128,41 +130,42 @@ static char tftp_filename[MAX_LEN];
#define TFTP_MTU_BLOCKSIZE 1468
#endif
static unsigned short TftpBlkSize = TFTP_BLOCK_SIZE;
static unsigned short TftpBlkSizeOption = TFTP_MTU_BLOCKSIZE;
static unsigned short tftp_block_size = TFTP_BLOCK_SIZE;
static unsigned short tftp_block_size_option = TFTP_MTU_BLOCKSIZE;
#ifdef CONFIG_MCAST_TFTP
#include <malloc.h>
#define MTFTP_BITMAPSIZE 0x1000
static unsigned *Bitmap;
static int PrevBitmapHole, Mapsize = MTFTP_BITMAPSIZE;
static uchar ProhibitMcast, MasterClient;
static uchar Multicast;
static int Mcast_port;
static ulong TftpEndingBlock; /* can get 'last' block before done..*/
static unsigned *tftp_mcast_bitmap;
static int tftp_mcast_prev_hole;
static int tftp_mcast_bitmap_size = MTFTP_BITMAPSIZE;
static int tftp_mcast_disabled;
static int tftp_mcast_master_client;
static int tftp_mcast_active;
static int tftp_mcast_port;
/* can get 'last' block before done..*/
static ulong tftp_mcast_ending_block;
static void parse_multicast_oack(char *pkt, int len);
static void
mcast_cleanup(void)
static void mcast_cleanup(void)
{
if (net_mcast_addr)
eth_mcast_join(net_mcast_addr, 0);
if (Bitmap)
free(Bitmap);
Bitmap = NULL;
if (tftp_mcast_bitmap)
free(tftp_mcast_bitmap);
tftp_mcast_bitmap = NULL;
net_mcast_addr.s_addr = 0;
Multicast = 0;
Mcast_port = 0;
TftpEndingBlock = -1;
tftp_mcast_active = 0;
tftp_mcast_port = 0;
tftp_mcast_ending_block = -1;
}
#endif /* CONFIG_MCAST_TFTP */
static inline void
store_block(int block, uchar *src, unsigned len)
static inline void store_block(int block, uchar *src, unsigned len)
{
ulong offset = block * TftpBlkSize + TftpBlockWrapOffset;
ulong offset = block * tftp_block_size + tftp_block_wrap_offset;
ulong newsize = offset + len;
#ifdef CONFIG_SYS_DIRECT_FLASH_TFTP
int i, rc = 0;
@ -193,8 +196,8 @@ store_block(int block, uchar *src, unsigned len)
unmap_sysmem(ptr);
}
#ifdef CONFIG_MCAST_TFTP
if (Multicast)
ext2_set_bit(block, Bitmap);
if (tftp_mcast_active)
ext2_set_bit(block, tftp_mcast_bitmap);
#endif
if (net_boot_file_size < newsize)
@ -204,11 +207,11 @@ store_block(int block, uchar *src, unsigned len)
/* Clear our state ready for a new transfer */
static void new_transfer(void)
{
TftpLastBlock = 0;
TftpBlockWrap = 0;
TftpBlockWrapOffset = 0;
tftp_prev_block = 0;
tftp_block_wrap = 0;
tftp_block_wrap_offset = 0;
#ifdef CONFIG_CMD_TFTPPUT
TftpFinalBlock = 0;
tftp_put_final_block_sent = 0;
#endif
}
@ -224,38 +227,39 @@ static void new_transfer(void)
static int load_block(unsigned block, uchar *dst, unsigned len)
{
/* We may want to get the final block from the previous set */
ulong offset = ((int)block - 1) * len + TftpBlockWrapOffset;
ulong offset = ((int)block - 1) * len + tftp_block_wrap_offset;
ulong tosend = len;
tosend = min(net_boot_file_size - offset, tosend);
(void)memcpy(dst, (void *)(save_addr + offset), tosend);
debug("%s: block=%d, offset=%ld, len=%d, tosend=%ld\n", __func__,
block, offset, len, tosend);
block, offset, len, tosend);
return tosend;
}
#endif
static void TftpSend(void);
static void TftpTimeout(void);
static void tftp_send(void);
static void tftp_timeout_handler(void);
/**********************************************************************/
static void show_block_marker(void)
{
#ifdef CONFIG_TFTP_TSIZE
if (TftpTsize) {
ulong pos = TftpBlock * TftpBlkSize + TftpBlockWrapOffset;
if (tftp_tsize) {
ulong pos = tftp_cur_block * tftp_block_size +
tftp_block_wrap_offset;
while (TftpNumchars < pos * 50 / TftpTsize) {
while (tftp_tsize_num_hash < pos * 50 / tftp_tsize) {
putc('#');
TftpNumchars++;
tftp_tsize_num_hash++;
}
} else
#endif
{
if (((TftpBlock - 1) % 10) == 0)
if (((tftp_cur_block - 1) % 10) == 0)
putc('#');
else if ((TftpBlock % (10 * HASHES_PER_LINE)) == 0)
else if ((tftp_cur_block % (10 * HASHES_PER_LINE)) == 0)
puts("\n\t ");
}
}
@ -287,10 +291,10 @@ static void update_block_number(void)
* number of 0 this means that there was a wrap
* around of the (16 bit) counter.
*/
if (TftpBlock == 0 && TftpLastBlock != 0) {
TftpBlockWrap++;
TftpBlockWrapOffset += TftpBlkSize * TFTP_SEQUENCE_SIZE;
TftpTimeoutCount = 0; /* we've done well, reset thhe timeout */
if (tftp_cur_block == 0 && tftp_prev_block != 0) {
tftp_block_wrap++;
tftp_block_wrap_offset += tftp_block_size * TFTP_SEQUENCE_SIZE;
timeout_count = 0; /* we've done well, reset the timeout */
} else {
show_block_marker();
}
@ -301,12 +305,12 @@ static void tftp_complete(void)
{
#ifdef CONFIG_TFTP_TSIZE
/* Print hash marks for the last packet received */
while (TftpTsize && TftpNumchars < 49) {
while (tftp_tsize && tftp_tsize_num_hash < 49) {
putc('#');
TftpNumchars++;
tftp_tsize_num_hash++;
}
puts(" ");
print_size(TftpTsize, "");
print_size(tftp_tsize, "");
#endif
time_start = get_timer(time_start);
if (time_start > 0) {
@ -318,8 +322,7 @@ static void tftp_complete(void)
net_set_state(NETLOOP_SUCCESS);
}
static void
TftpSend(void)
static void tftp_send(void)
{
uchar *pkt;
uchar *xp;
@ -328,9 +331,8 @@ TftpSend(void)
#ifdef CONFIG_MCAST_TFTP
/* Multicast TFTP.. non-MasterClients do not ACK data. */
if (Multicast
&& (TftpState == STATE_DATA)
&& (MasterClient == 0))
if (tftp_mcast_active && tftp_state == STATE_DATA &&
tftp_mcast_master_client == 0)
return;
#endif
/*
@ -339,13 +341,13 @@ TftpSend(void)
*/
pkt = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE;
switch (TftpState) {
switch (tftp_state) {
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 :
*s++ = htons(tftp_state == STATE_SEND_RRQ ? TFTP_RRQ :
TFTP_WRQ);
#else
*s++ = htons(TFTP_RRQ);
@ -357,7 +359,7 @@ TftpSend(void)
pkt += 5 /*strlen("octet")*/ + 1;
strcpy((char *)pkt, "timeout");
pkt += 7 /*strlen("timeout")*/ + 1;
sprintf((char *)pkt, "%lu", TftpTimeoutMSecs / 1000);
sprintf((char *)pkt, "%lu", timeout_ms / 1000);
debug("send option \"timeout %s\"\n", (char *)pkt);
pkt += strlen((char *)pkt) + 1;
#ifdef CONFIG_TFTP_TSIZE
@ -366,14 +368,14 @@ TftpSend(void)
#endif
/* try for more effic. blk size */
pkt += sprintf((char *)pkt, "blksize%c%d%c",
0, TftpBlkSizeOption, 0);
0, tftp_block_size_option, 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;
if (!tftp_mcast_disabled) {
tftp_mcast_bitmap = malloc(tftp_mcast_bitmap_size);
if (tftp_mcast_bitmap && eth_get_dev()->mcast) {
free(tftp_mcast_bitmap);
tftp_mcast_bitmap = NULL;
pkt += sprintf((char *)pkt, "multicast%c%c",
0, 0);
}
@ -384,11 +386,12 @@ TftpSend(void)
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..*/
/* My turn! Start at where I need blocks I missed. */
if (tftp_mcast_active)
tftp_cur_block = ext2_find_next_zero_bit(
tftp_mcast_bitmap,
tftp_mcast_bitmap_size * 8, 0);
/* fall through */
#endif
case STATE_RECV_WRQ:
@ -396,16 +399,16 @@ TftpSend(void)
xp = pkt;
s = (ushort *)pkt;
s[0] = htons(TFTP_ACK);
s[1] = htons(TftpBlock);
s[1] = htons(tftp_cur_block);
pkt = (uchar *)(s + 2);
#ifdef CONFIG_CMD_TFTPPUT
if (TftpWriting) {
int toload = TftpBlkSize;
int loaded = load_block(TftpBlock, pkt, toload);
if (tftp_put_active) {
int toload = tftp_block_size;
int loaded = load_block(tftp_cur_block, pkt, toload);
s[0] = htons(TFTP_DATA);
pkt += loaded;
TftpFinalBlock = (loaded < toload);
tftp_put_final_block_sent = (loaded < toload);
}
#endif
len = pkt - xp;
@ -435,8 +438,8 @@ TftpSend(void)
break;
}
net_send_udp_packet(net_server_ethaddr, tftp_remote_ip, TftpRemotePort,
TftpOurPort, len);
net_send_udp_packet(net_server_ethaddr, tftp_remote_ip,
tftp_remote_port, tftp_our_port, len);
}
#ifdef CONFIG_CMD_TFTPPUT
@ -458,15 +461,15 @@ static void tftp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
__be16 *s;
int i;
if (dest != TftpOurPort) {
if (dest != tftp_our_port) {
#ifdef CONFIG_MCAST_TFTP
if (Multicast
&& (!Mcast_port || (dest != Mcast_port)))
if (tftp_mcast_active &&
(!tftp_mcast_port || dest != tftp_mcast_port))
#endif
return;
}
if (TftpState != STATE_SEND_RRQ && src != TftpRemotePort &&
TftpState != STATE_RECV_WRQ && TftpState != STATE_SEND_WRQ)
if (tftp_state != STATE_SEND_RRQ && src != tftp_remote_port &&
tftp_state != STATE_RECV_WRQ && tftp_state != STATE_SEND_WRQ)
return;
if (len < 2)
@ -477,14 +480,13 @@ static void tftp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
proto = *s++;
pkt = (uchar *)s;
switch (ntohs(proto)) {
case TFTP_RRQ:
break;
case TFTP_ACK:
#ifdef CONFIG_CMD_TFTPPUT
if (TftpWriting) {
if (TftpFinalBlock) {
if (tftp_put_active) {
if (tftp_put_final_block_sent) {
tftp_complete();
} else {
/*
@ -492,12 +494,12 @@ static void tftp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
* count to wrap just like the other end!
*/
int block = ntohs(*s);
int ack_ok = (TftpBlock == block);
int ack_ok = (tftp_cur_block == block);
TftpBlock = (unsigned short)(block + 1);
tftp_cur_block = (unsigned short)(block + 1);
update_block_number();
if (ack_ok)
TftpSend(); /* Send next data block */
tftp_send(); /* Send next data block */
}
}
#endif
@ -510,101 +512,98 @@ static void tftp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
case TFTP_WRQ:
debug("Got WRQ\n");
tftp_remote_ip = sip;
TftpRemotePort = src;
TftpOurPort = 1024 + (get_timer(0) % 3072);
tftp_remote_port = src;
tftp_our_port = 1024 + (get_timer(0) % 3072);
new_transfer();
TftpSend(); /* Send ACK(0) */
tftp_send(); /* Send ACK(0) */
break;
#endif
case TFTP_OACK:
debug("Got OACK: %s %s\n",
pkt,
pkt + strlen((char *)pkt) + 1);
TftpState = STATE_OACK;
TftpRemotePort = src;
pkt, pkt + strlen((char *)pkt) + 1);
tftp_state = STATE_OACK;
tftp_remote_port = src;
/*
* Check for 'blksize' option.
* Careful: "i" is signed, "len" is unsigned, thus
* something like "len-8" may give a *huge* number
*/
for (i = 0; i+8 < len; i++) {
if (strcmp((char *)pkt+i, "blksize") == 0) {
TftpBlkSize = (unsigned short)
simple_strtoul((char *)pkt+i+8, NULL,
10);
if (strcmp((char *)pkt + i, "blksize") == 0) {
tftp_block_size = (unsigned short)
simple_strtoul((char *)pkt + i + 8,
NULL, 10);
debug("Blocksize ack: %s, %d\n",
(char *)pkt+i+8, TftpBlkSize);
(char *)pkt + i + 8, tftp_block_size);
}
#ifdef CONFIG_TFTP_TSIZE
if (strcmp((char *)pkt+i, "tsize") == 0) {
TftpTsize = simple_strtoul((char *)pkt+i+6,
tftp_tsize = simple_strtoul((char *)pkt + i + 6,
NULL, 10);
debug("size = %s, %d\n",
(char *)pkt+i+6, TftpTsize);
(char *)pkt + i + 6, tftp_tsize);
}
#endif
}
#ifdef CONFIG_MCAST_TFTP
parse_multicast_oack((char *)pkt, len-1);
if ((Multicast) && (!MasterClient))
TftpState = STATE_DATA; /* passive.. */
parse_multicast_oack((char *)pkt, len - 1);
if ((tftp_mcast_active) && (!tftp_mcast_master_client))
tftp_state = STATE_DATA; /* passive.. */
else
#endif
#ifdef CONFIG_CMD_TFTPPUT
if (TftpWriting) {
if (tftp_put_active) {
/* Get ready to send the first block */
TftpState = STATE_DATA;
TftpBlock++;
tftp_state = STATE_DATA;
tftp_cur_block++;
}
#endif
TftpSend(); /* Send ACK or first data block */
tftp_send(); /* Send ACK or first data block */
break;
case TFTP_DATA:
if (len < 2)
return;
len -= 2;
TftpBlock = ntohs(*(__be16 *)pkt);
tftp_cur_block = ntohs(*(__be16 *)pkt);
update_block_number();
if (TftpState == STATE_SEND_RRQ)
if (tftp_state == STATE_SEND_RRQ)
debug("Server did not acknowledge timeout option!\n");
if (TftpState == STATE_SEND_RRQ || TftpState == STATE_OACK ||
TftpState == STATE_RECV_WRQ) {
if (tftp_state == STATE_SEND_RRQ || tftp_state == STATE_OACK ||
tftp_state == STATE_RECV_WRQ) {
/* first block received */
TftpState = STATE_DATA;
TftpRemotePort = src;
tftp_state = STATE_DATA;
tftp_remote_port = src;
new_transfer();
#ifdef CONFIG_MCAST_TFTP
if (Multicast) { /* start!=1 common if mcast */
TftpLastBlock = TftpBlock - 1;
if (tftp_mcast_active) { /* start!=1 common if mcast */
tftp_prev_block = tftp_cur_block - 1;
} else
#endif
if (TftpBlock != 1) { /* Assertion */
printf("\nTFTP error: "
"First block is not block 1 (%ld)\n"
"Starting again\n\n",
TftpBlock);
if (tftp_cur_block != 1) { /* Assertion */
puts("\nTFTP error: ");
printf("First block is not block 1 (%ld)\n",
tftp_cur_block);
puts("Starting again\n\n");
NetStartAgain();
break;
}
}
if (TftpBlock == TftpLastBlock) {
/*
* Same block again; ignore it.
*/
if (tftp_cur_block == tftp_prev_block) {
/* Same block again; ignore it. */
break;
}
TftpLastBlock = TftpBlock;
TftpTimeoutCountMax = TIMEOUT_COUNT;
NetSetTimeout(TftpTimeoutMSecs, TftpTimeout);
tftp_prev_block = tftp_cur_block;
timeout_count_max = TIMEOUT_COUNT;
NetSetTimeout(timeout_ms, tftp_timeout_handler);
store_block(TftpBlock - 1, pkt + 2, len);
store_block(tftp_cur_block - 1, pkt + 2, len);
/*
* Acknowledge the block just received, which will prompt
@ -614,39 +613,41 @@ static void tftp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
/* if I am the MasterClient, actively calculate what my next
* needed block is; else I'm passive; not ACKING
*/
if (Multicast) {
if (len < TftpBlkSize) {
TftpEndingBlock = TftpBlock;
} else if (MasterClient) {
TftpBlock = PrevBitmapHole =
ext2_find_next_zero_bit(
Bitmap,
(Mapsize*8),
PrevBitmapHole);
if (TftpBlock > ((Mapsize*8) - 1)) {
printf("tftpfile too big\n");
if (tftp_mcast_active) {
if (len < tftp_block_size) {
tftp_mcast_ending_block = tftp_cur_block;
} else if (tftp_mcast_master_client) {
tftp_mcast_prev_hole = ext2_find_next_zero_bit(
tftp_mcast_bitmap,
tftp_mcast_bitmap_size * 8,
tftp_mcast_prev_hole);
tftp_cur_block = tftp_mcast_prev_hole;
if (tftp_cur_block >
((tftp_mcast_bitmap_size * 8) - 1)) {
debug("tftpfile too big\n");
/* try to double it and retry */
Mapsize <<= 1;
tftp_mcast_bitmap_size <<= 1;
mcast_cleanup();
NetStartAgain();
return;
}
TftpLastBlock = TftpBlock;
tftp_prev_block = tftp_cur_block;
}
}
#endif
TftpSend();
tftp_send();
#ifdef CONFIG_MCAST_TFTP
if (Multicast) {
if (MasterClient && (TftpBlock >= TftpEndingBlock)) {
if (tftp_mcast_active) {
if (tftp_mcast_master_client &&
(tftp_cur_block >= tftp_mcast_ending_block)) {
puts("\nMulticast tftp done\n");
mcast_cleanup();
net_set_state(NETLOOP_SUCCESS);
}
} else
#endif
if (len < TftpBlkSize)
if (len < tftp_block_size)
tftp_complete();
break;
@ -679,21 +680,20 @@ static void tftp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
}
static void
TftpTimeout(void)
static void tftp_timeout_handler(void)
{
if (++TftpTimeoutCount > TftpTimeoutCountMax) {
if (++timeout_count > timeout_count_max) {
restart("Retry count exceeded");
} else {
puts("T ");
NetSetTimeout(TftpTimeoutMSecs, TftpTimeout);
if (TftpState != STATE_RECV_WRQ)
TftpSend();
NetSetTimeout(timeout_ms, tftp_timeout_handler);
if (tftp_state != STATE_RECV_WRQ)
tftp_send();
}
}
void TftpStart(enum proto_t protocol)
void tftp_start(enum proto_t protocol)
{
char *ep; /* Environment pointer */
@ -703,21 +703,20 @@ void TftpStart(enum proto_t protocol)
*/
ep = getenv("tftpblocksize");
if (ep != NULL)
TftpBlkSizeOption = simple_strtol(ep, NULL, 10);
tftp_block_size_option = simple_strtol(ep, NULL, 10);
ep = getenv("tftptimeout");
if (ep != NULL)
TftpTimeoutMSecs = simple_strtol(ep, NULL, 10);
timeout_ms = simple_strtol(ep, NULL, 10);
if (TftpTimeoutMSecs < 1000) {
printf("TFTP timeout (%ld ms) too low, "
"set minimum = 1000 ms\n",
TftpTimeoutMSecs);
TftpTimeoutMSecs = 1000;
if (timeout_ms < 1000) {
printf("TFTP timeout (%ld ms) too low, set min = 1000 ms\n",
timeout_ms);
timeout_ms = 1000;
}
debug("TFTP blocksize = %i, timeout = %ld ms\n",
TftpBlkSizeOption, TftpTimeoutMSecs);
tftp_block_size_option, timeout_ms);
tftp_remote_ip = net_server_ip;
if (net_boot_file_name[0] == '\0') {
@ -728,20 +727,20 @@ void TftpStart(enum proto_t protocol)
(net_ip.s_addr >> 24) & 0xFF);
strncpy(tftp_filename, default_filename, MAX_LEN);
tftp_filename[MAX_LEN-1] = 0;
tftp_filename[MAX_LEN - 1] = 0;
printf("*** Warning: no boot file name; using '%s'\n",
tftp_filename);
tftp_filename);
} else {
char *p = strchr(net_boot_file_name, ':');
if (p == NULL) {
strncpy(tftp_filename, net_boot_file_name, MAX_LEN);
tftp_filename[MAX_LEN-1] = 0;
tftp_filename[MAX_LEN - 1] = 0;
} else {
tftp_remote_ip = string_to_ip(net_boot_file_name);
strncpy(tftp_filename, p + 1, MAX_LEN);
tftp_filename[MAX_LEN-1] = 0;
tftp_filename[MAX_LEN - 1] = 0;
}
}
@ -750,9 +749,9 @@ void TftpStart(enum proto_t protocol)
#ifdef CONFIG_CMD_TFTPPUT
protocol == TFTPPUT ? "to" : "from",
#else
"from",
"from",
#endif
&tftp_remote_ip, &net_ip);
&tftp_remote_ip, &net_ip);
/* Check if we need to send across this subnet */
if (net_gateway.s_addr && net_netmask.s_addr) {
@ -776,63 +775,62 @@ void TftpStart(enum proto_t protocol)
putc('\n');
#ifdef CONFIG_CMD_TFTPPUT
TftpWriting = (protocol == TFTPPUT);
if (TftpWriting) {
tftp_put_active = (protocol == TFTPPUT);
if (tftp_put_active) {
printf("Save address: 0x%lx\n", save_addr);
printf("Save size: 0x%lx\n", save_size);
net_boot_file_size = save_size;
puts("Saving: *\b");
TftpState = STATE_SEND_WRQ;
tftp_state = STATE_SEND_WRQ;
new_transfer();
} else
#endif
{
printf("Load address: 0x%lx\n", load_addr);
puts("Loading: *\b");
TftpState = STATE_SEND_RRQ;
tftp_state = STATE_SEND_RRQ;
}
time_start = get_timer(0);
TftpTimeoutCountMax = TftpRRQTimeoutCountMax;
timeout_count_max = tftp_timeout_count_max;
NetSetTimeout(TftpTimeoutMSecs, TftpTimeout);
NetSetTimeout(timeout_ms, tftp_timeout_handler);
net_set_udp_handler(tftp_handler);
#ifdef CONFIG_CMD_TFTPPUT
net_set_icmp_handler(icmp_handler);
#endif
TftpRemotePort = WELL_KNOWN_PORT;
TftpTimeoutCount = 0;
tftp_remote_port = WELL_KNOWN_PORT;
timeout_count = 0;
/* Use a pseudo-random port unless a specific port is set */
TftpOurPort = 1024 + (get_timer(0) % 3072);
tftp_our_port = 1024 + (get_timer(0) % 3072);
#ifdef CONFIG_TFTP_PORT
ep = getenv("tftpdstp");
if (ep != NULL)
TftpRemotePort = simple_strtol(ep, NULL, 10);
tftp_remote_port = simple_strtol(ep, NULL, 10);
ep = getenv("tftpsrcp");
if (ep != NULL)
TftpOurPort = simple_strtol(ep, NULL, 10);
tftp_our_port = simple_strtol(ep, NULL, 10);
#endif
TftpBlock = 0;
tftp_cur_block = 0;
/* zero out server ether in case the server ip has changed */
memset(net_server_ethaddr, 0, 6);
/* Revert TftpBlkSize to dflt */
TftpBlkSize = TFTP_BLOCK_SIZE;
/* Revert tftp_block_size to dflt */
tftp_block_size = TFTP_BLOCK_SIZE;
#ifdef CONFIG_MCAST_TFTP
mcast_cleanup();
#endif
#ifdef CONFIG_TFTP_TSIZE
TftpTsize = 0;
TftpNumchars = 0;
tftp_tsize = 0;
tftp_tsize_num_hash = 0;
#endif
TftpSend();
tftp_send();
}
#ifdef CONFIG_CMD_TFTPSRV
void
TftpStartServer(void)
void tftp_start_server(void)
{
tftp_filename[0] = 0;
@ -842,22 +840,22 @@ TftpStartServer(void)
puts("Loading: *\b");
TftpTimeoutCountMax = TIMEOUT_COUNT;
TftpTimeoutCount = 0;
TftpTimeoutMSecs = TIMEOUT;
NetSetTimeout(TftpTimeoutMSecs, TftpTimeout);
timeout_count_max = TIMEOUT_COUNT;
timeout_count = 0;
timeout_ms = TIMEOUT;
NetSetTimeout(timeout_ms, tftp_timeout_handler);
/* Revert TftpBlkSize to dflt */
TftpBlkSize = TFTP_BLOCK_SIZE;
TftpBlock = 0;
TftpOurPort = WELL_KNOWN_PORT;
/* Revert tftp_block_size to dflt */
tftp_block_size = TFTP_BLOCK_SIZE;
tftp_cur_block = 0;
tftp_our_port = WELL_KNOWN_PORT;
#ifdef CONFIG_TFTP_TSIZE
TftpTsize = 0;
TftpNumchars = 0;
tftp_tsize = 0;
tftp_tsize_num_hash = 0;
#endif
TftpState = STATE_RECV_WRQ;
tftp_state = STATE_RECV_WRQ;
net_set_udp_handler(tftp_handler);
/* zero out server ether in case the server ip has changed */
@ -866,10 +864,12 @@ TftpStartServer(void)
#endif /* CONFIG_CMD_TFTPSRV */
#ifdef CONFIG_MCAST_TFTP
/* Credits: atftp project.
/*
* Credits: atftp project.
*/
/* pick up BcastAddr, Port, and whether I am [now] the master-client. *
/*
* Pick up BcastAddr, Port, and whether I am [now] the master-client.
* Frame:
* +-------+-----------+---+-------~~-------+---+
* | opc | multicast | 0 | addr, port, mc | 0 |
@ -885,58 +885,62 @@ static void parse_multicast_oack(char *pkt, int len)
{
int i;
struct in_addr addr;
char *mc_adr, *port, *mc;
char *mc_adr;
char *port;
char *mc;
mc_adr = port = mc = NULL;
mc_adr = NULL;
port = NULL;
mc = NULL;
/* march along looking for 'multicast\0', which has to start at least
* 14 bytes back from the end.
*/
for (i = 0; i < len-14; i++)
if (strcmp(pkt+i, "multicast") == 0)
for (i = 0; i < len - 14; i++)
if (strcmp(pkt + i, "multicast") == 0)
break;
if (i >= (len-14)) /* non-Multicast OACK, ign. */
if (i >= (len - 14)) /* non-Multicast OACK, ign. */
return;
i += 10; /* strlen multicast */
mc_adr = pkt+i;
mc_adr = pkt + i;
for (; i < len; i++) {
if (*(pkt+i) == ',') {
*(pkt+i) = '\0';
if (*(pkt + i) == ',') {
*(pkt + i) = '\0';
if (port) {
mc = pkt+i+1;
mc = pkt + i + 1;
break;
} else {
port = pkt+i+1;
port = pkt + i + 1;
}
}
}
if (!port || !mc_adr || !mc)
return;
if (Multicast && MasterClient) {
if (tftp_mcast_active && tftp_mcast_master_client) {
printf("I got a OACK as master Client, WRONG!\n");
return;
}
/* ..I now accept packets destined for this MCAST addr, port */
if (!Multicast) {
if (Bitmap) {
if (!tftp_mcast_active) {
if (tftp_mcast_bitmap) {
printf("Internal failure! no mcast.\n");
free(Bitmap);
Bitmap = NULL;
ProhibitMcast = 1;
return ;
free(tftp_mcast_bitmap);
tftp_mcast_bitmap = NULL;
tftp_mcast_disabled = 1;
return;
}
/* I malloc instead of pre-declare; so that if the file ends
* up being too big for this bitmap I can retry
*/
Bitmap = malloc(Mapsize);
if (!Bitmap) {
printf("No Bitmap, no multicast. Sorry.\n");
ProhibitMcast = 1;
tftp_mcast_bitmap = malloc(tftp_mcast_bitmap_size);
if (!tftp_mcast_bitmap) {
printf("No bitmap, no multicast. Sorry.\n");
tftp_mcast_disabled = 1;
return;
}
memset(Bitmap, 0, Mapsize);
PrevBitmapHole = 0;
Multicast = 1;
memset(tftp_mcast_bitmap, 0, tftp_mcast_bitmap_size);
tftp_mcast_prev_hole = 0;
tftp_mcast_active = 1;
}
addr = string_to_ip(mc_adr);
if (net_mcast_addr.s_addr != addr.s_addr) {
@ -945,14 +949,15 @@ static void parse_multicast_oack(char *pkt, int len)
net_mcast_addr = addr;
if (eth_mcast_join(net_mcast_addr, 1)) {
printf("Fail to set mcast, revert to TFTP\n");
ProhibitMcast = 1;
tftp_mcast_disabled = 1;
mcast_cleanup();
NetStartAgain();
}
}
MasterClient = (unsigned char)simple_strtoul((char *)mc, NULL, 10);
Mcast_port = (unsigned short)simple_strtoul(port, NULL, 10);
printf("Multicast: %s:%d [%d]\n", mc_adr, Mcast_port, MasterClient);
tftp_mcast_master_client = simple_strtoul((char *)mc, NULL, 10);
tftp_mcast_port = (unsigned short)simple_strtoul(port, NULL, 10);
printf("Multicast: %s:%d [%d]\n", mc_adr, tftp_mcast_port,
tftp_mcast_master_client);
return;
}

8
net/tftp.h
Unescape View File

@ -16,14 +16,14 @@
*/
/* tftp.c */
void TftpStart(enum proto_t protocol); /* Begin TFTP get/put */
void tftp_start(enum proto_t protocol); /* Begin TFTP get/put */
#ifdef CONFIG_CMD_TFTPSRV
extern void TftpStartServer(void); /* Wait for incoming TFTP put */
void tftp_start_server(void); /* Wait for incoming TFTP put */
#endif
extern ulong TftpRRQTimeoutMSecs;
extern int TftpRRQTimeoutCountMax;
extern ulong tftp_timeout_ms;
extern int tftp_timeout_count_max;
/**********************************************************************/

Write Preview
Loading…
Cancel
Save