net: cosmetic: Clean up TFTP variables and functions

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>

1 files changed, 244 insertions, 239 deletions

diff --git a/net/tftp.c b/net/tftp.c
index f25abaab49..14acf04e1f 100644
--- a/net/tftp.c
+++ b/net/tftp.c
@@ -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;
 }