Add svn:eol-style property to source files, so that the line endings are correctly converted to the target system's native end of line style.

30 files changed, 12419 insertions, 12419 deletions

diff --git a/Projects/Webserver/Lib/DHCPClientApp.c b/Projects/Webserver/Lib/DHCPClientApp.c
index 9d085a785..7f822538e 100644
--- a/Projects/Webserver/Lib/DHCPClientApp.c
+++ b/Projects/Webserver/Lib/DHCPClientApp.c
@@ -1,264 +1,264 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-#if defined(ENABLE_DHCP_CLIENT) || defined(__DOXYGEN__)

-

-/** \file

- *

- *  DHCP Client Application. When connected to the uIP stack, this will retrieve IP configuration settings from the

- *  DHCP server on the network.

- */

-

-#define  INCLUDE_FROM_DHCPCLIENTAPP_C

-#include "DHCPClientApp.h"

-

-/** Initialization function for the DHCP client. */

-void DHCPClientApp_Init(void)

-{

-	/* Create a new UDP connection to the DHCP server port for the DHCP solicitation */

-	struct uip_udp_conn* Connection = uip_udp_new(&uip_broadcast_addr, HTONS(DHCPC_SERVER_PORT));

-	

-	/* If the connection was successfully created, bind it to the local DHCP client port */

-	if (Connection != NULL)

-	{

-		uip_udp_appstate_t* const AppState = &Connection->appstate;

-		uip_udp_bind(Connection, HTONS(DHCPC_CLIENT_PORT));

-		

-		/* Set the initial client state */

-		AppState->DHCPClient.CurrentState = DHCP_STATE_SendDiscover;

-

-		/* Set timeout period to half a second for a DHCP server to respond */

-		timer_set(&AppState->DHCPClient.Timeout, CLOCK_SECOND / 2);

-	}

-}

- 

-/** uIP stack application callback for the DHCP client. This function must be called each time the TCP/IP stack 

- *  needs a UDP packet to be processed.

- */

-void DHCPClientApp_Callback(void)

-{

-	uip_udp_appstate_t* const AppState    = &uip_udp_conn->appstate;

-	DHCP_Header_t*      const AppData     = (DHCP_Header_t*)uip_appdata;

-	uint16_t                  AppDataSize = 0;

-	

-	switch (AppState->DHCPClient.CurrentState)

-	{

-		case DHCP_STATE_SendDiscover:

-			/* Clear all DHCP settings, reset client IP address */

-			memset(&AppState->DHCPClient.DHCPOffer_Data, 0x00, sizeof(AppState->DHCPClient.DHCPOffer_Data));

-			uip_sethostaddr((uip_ipaddr_t*)&AppState->DHCPClient.DHCPOffer_Data.AllocatedIP);

-

-			/* Fill out the DHCP response header */

-			AppDataSize += DHCPClientApp_FillDHCPHeader(AppData, DHCP_DISCOVER, AppState);

-			

-			/* Add the required DHCP options list to the packet */

-			uint8_t RequiredOptionList[] = {DHCP_OPTION_SUBNET_MASK, DHCP_OPTION_ROUTER, DHCP_OPTION_DNS_SERVER};

-			AppDataSize += DHCPClientApp_SetOption(AppData->Options, DHCP_OPTION_REQ_LIST, sizeof(RequiredOptionList),

-			                                       RequiredOptionList);			

-			

-			/* Send the DHCP DISCOVER packet */

-			uip_udp_send(AppDataSize);

-

-			/* Reset the timeout timer, progress to next state */

-			timer_reset(&AppState->DHCPClient.Timeout);

-			AppState->DHCPClient.CurrentState = DHCP_STATE_WaitForOffer;			

-			

-			break;

-		case DHCP_STATE_WaitForOffer:

-			if (!(uip_newdata()))

-			{

-				/* Check if the DHCP timeout period has expired while waiting for a response */

-				if (timer_expired(&AppState->DHCPClient.Timeout))

-				  AppState->DHCPClient.CurrentState = DHCP_STATE_SendDiscover;

-				

-				break;

-			}

-			  

-			uint8_t OfferResponse_MessageType;

-			if ((AppData->TransactionID == DHCP_TRANSACTION_ID) &&

-			    DHCPClientApp_GetOption(AppData->Options, DHCP_OPTION_MSG_TYPE, &OfferResponse_MessageType) &&

-			    (OfferResponse_MessageType == DHCP_OFFER))

-			{

-				/* Received a DHCP offer for an IP address, copy over values for later request */

-				memcpy(&AppState->DHCPClient.DHCPOffer_Data.AllocatedIP, &AppData->YourIP, sizeof(uip_ipaddr_t));

-				DHCPClientApp_GetOption(AppData->Options, DHCP_OPTION_SUBNET_MASK, &AppState->DHCPClient.DHCPOffer_Data.Netmask);

-				DHCPClientApp_GetOption(AppData->Options, DHCP_OPTION_ROUTER,      &AppState->DHCPClient.DHCPOffer_Data.GatewayIP);

-				DHCPClientApp_GetOption(AppData->Options, DHCP_OPTION_SERVER_ID,   &AppState->DHCPClient.DHCPOffer_Data.ServerIP);

-				

-				timer_reset(&AppState->DHCPClient.Timeout);

-				AppState->DHCPClient.CurrentState = DHCP_STATE_SendRequest;

-			}

-

-			break;

-		case DHCP_STATE_SendRequest:

-			/* Fill out the DHCP response header */

-			AppDataSize += DHCPClientApp_FillDHCPHeader(AppData, DHCP_REQUEST, AppState);

-

-			/* Add the DHCP REQUESTED IP ADDRESS option to the packet */

-			AppDataSize += DHCPClientApp_SetOption(AppData->Options, DHCP_OPTION_REQ_IPADDR, sizeof(uip_ipaddr_t),

-			                                       &AppState->DHCPClient.DHCPOffer_Data.AllocatedIP);

-

-			/* Add the DHCP SERVER IP ADDRESS option to the packet */

-			AppDataSize += DHCPClientApp_SetOption(AppData->Options, DHCP_OPTION_SERVER_ID, sizeof(uip_ipaddr_t),

-			                                       &AppState->DHCPClient.DHCPOffer_Data.ServerIP);

-

-			/* Send the DHCP REQUEST packet */

-			uip_udp_send(AppDataSize);

-			

-			/* Reset the timeout timer, progress to next state */

-			timer_reset(&AppState->DHCPClient.Timeout);

-			AppState->DHCPClient.CurrentState = DHCP_STATE_WaitForACK;

-

-			break;

-		case DHCP_STATE_WaitForACK:

-			if (!(uip_newdata()))

-			{

-				/* Check if the DHCP timeout period has expired while waiting for a response */

-				if (timer_expired(&AppState->DHCPClient.Timeout))

-				  AppState->DHCPClient.CurrentState = DHCP_STATE_SendDiscover;

-				

-				break;

-			}

-			

-			uint8_t RequestResponse_MessageType;

-			if ((AppData->TransactionID == DHCP_TRANSACTION_ID) &&

-			    DHCPClientApp_GetOption(AppData->Options, DHCP_OPTION_MSG_TYPE, &RequestResponse_MessageType) &&

-			    (RequestResponse_MessageType == DHCP_ACK))

-			{

-				/* Set the new network parameters from the DHCP server */

-				uip_sethostaddr((uip_ipaddr_t*)&AppState->DHCPClient.DHCPOffer_Data.AllocatedIP);

-				uip_setnetmask((uip_ipaddr_t*)&AppState->DHCPClient.DHCPOffer_Data.Netmask);

-				uip_setdraddr((uip_ipaddr_t*)&AppState->DHCPClient.DHCPOffer_Data.GatewayIP);

-			

-				/* Indicate to the user that we now have a valid IP configuration */

-				HaveIPConfiguration = true;

-

-				AppState->DHCPClient.CurrentState = DHCP_STATE_AddressLeased;				

-			}

-			

-			break;

-	}

-}

-

-/** Fills the DHCP packet response with the appropriate BOOTP header for DHCP. This fills out all the required

- *  fields, leaving only the additional DHCP options to be added to the packet before it is sent to the DHCP server.

- *

- *  \param[out] DHCPHeader  Location in the packet buffer where the BOOTP header should be written to

- *  \param[in]  DHCPMessageType  DHCP Message type, such as DHCP_DISCOVER

- *  \param[in]  AppState    Application state of the current UDP connection

- *

- *  \return Size in bytes of the created DHCP packet

- */

-static uint16_t DHCPClientApp_FillDHCPHeader(DHCP_Header_t* const DHCPHeader, const uint8_t DHCPMessageType, uip_udp_appstate_t* AppState)

-{

-	/* Erase existing packet data so that we start will all 0x00 DHCP header data */

- 	memset(DHCPHeader, 0, sizeof(DHCP_Header_t));

-

-	/* Fill out the DHCP packet header */

-	DHCPHeader->Operation             = DHCP_OP_BOOTREQUEST;

-	DHCPHeader->HardwareType          = DHCP_HTYPE_ETHERNET;

-	DHCPHeader->HardwareAddressLength = sizeof(MACAddress);

-	DHCPHeader->Hops                  = 0;

-	DHCPHeader->TransactionID         = DHCP_TRANSACTION_ID;

-	DHCPHeader->ElapsedSeconds        = 0;

-	DHCPHeader->Flags                 = HTONS(BOOTP_BROADCAST);

-	memcpy(&DHCPHeader->ClientIP,     &uip_hostaddr,        sizeof(uip_ipaddr_t));

-	memcpy(&DHCPHeader->YourIP,       &AppState->DHCPClient.DHCPOffer_Data.AllocatedIP, sizeof(uip_ipaddr_t));

-	memcpy(&DHCPHeader->NextServerIP, &AppState->DHCPClient.DHCPOffer_Data.ServerIP,    sizeof(uip_ipaddr_t));

-	memcpy(&DHCPHeader->ClientHardwareAddress, &MACAddress, sizeof(struct uip_eth_addr));

-	DHCPHeader->Cookie                = DHCP_MAGIC_COOKIE;

-	

-	/* Add a DHCP message type and terminator options to the start of the DHCP options field */

-	DHCPHeader->Options[0]            = DHCP_OPTION_MSG_TYPE;

-	DHCPHeader->Options[1]            = 1;

-	DHCPHeader->Options[2]            = DHCPMessageType;

-	DHCPHeader->Options[3]            = DHCP_OPTION_END;

-	

-	/* Calculate the total number of bytes added to the outgoing packet */

-	return (sizeof(DHCP_Header_t) + 4);

-}

-

-/** Sets the given DHCP option in the DHCP packet's option list. This automatically moves the

- *  end of options terminator past the new option in the options list.

- *

- *  \param[in,out] DHCPOptionList  Pointer to the start of the DHCP packet's options list

- *  \param[in]     Option          DHCP option to add to the list

- *  \param[in]     DataLen         Size in bytes of the option data to add

- *  \param[in]     OptionData      Buffer where the option's data is to be sourced from

- *

- *  \return Number of bytes added to the DHCP packet

- */

-static uint8_t DHCPClientApp_SetOption(uint8_t* DHCPOptionList, uint8_t Option, uint8_t DataLen, void* OptionData)

-{

-	/* Skip through the DHCP options list until the terminator option is found */

-	while (*DHCPOptionList != DHCP_OPTION_END)

-	  DHCPOptionList += (DHCPOptionList[1] + 2);

-

-	/* Overwrite the existing terminator with the new option, add a new terminator at the end of the list */

-	DHCPOptionList[0] = Option;

-	DHCPOptionList[1] = DataLen;

-	memcpy(&DHCPOptionList[2], OptionData, DataLen);

-	DHCPOptionList[2 + DataLen] = DHCP_OPTION_END;

-	

-	/* Calculate the total number of bytes added to the outgoing packet */

-	return (2 + DataLen);

-}

-

-/** Retrieves the given option's data (if present) from the DHCP packet's options list.

- *

- *  \param[in,out] DHCPOptionList  Pointer to the start of the DHCP packet's options list

- *  \param[in]     Option          DHCP option to retrieve to the list

- *  \param[out]    Destination     Buffer where the option's data is to be written to if found

- *

- *  \return Boolean true if the option was found in the DHCP packet's options list, false otherwise

- */

-static bool DHCPClientApp_GetOption(const uint8_t* DHCPOptionList, const uint8_t Option, void* const Destination)

-{

-	/* Look through the incoming DHCP packet's options list for the requested option */

-	while (*DHCPOptionList != DHCP_OPTION_END)

-	{

-		/* Check if the current DHCP option in the packet is the one requested */

-		if (DHCPOptionList[0] == Option)

-		{

-			/* Copy request option's data to the destination buffer */

-			memcpy(Destination, &DHCPOptionList[2], DHCPOptionList[1]);

-			

-			/* Indicate that the requested option data was successfully retrieved */

-			return true;

-		}

-		

-		/* Skip to next DHCP option in the options list */

-		DHCPOptionList += (DHCPOptionList[1] + 2);

-	}

-	

-	/* Requested option not found in the incoming packet's DHCP options list */

-	return false;

-}

-#endif

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+#if defined(ENABLE_DHCP_CLIENT) || defined(__DOXYGEN__)
+
+/** \file
+ *
+ *  DHCP Client Application. When connected to the uIP stack, this will retrieve IP configuration settings from the
+ *  DHCP server on the network.
+ */
+
+#define  INCLUDE_FROM_DHCPCLIENTAPP_C
+#include "DHCPClientApp.h"
+
+/** Initialization function for the DHCP client. */
+void DHCPClientApp_Init(void)
+{
+	/* Create a new UDP connection to the DHCP server port for the DHCP solicitation */
+	struct uip_udp_conn* Connection = uip_udp_new(&uip_broadcast_addr, HTONS(DHCPC_SERVER_PORT));
+	
+	/* If the connection was successfully created, bind it to the local DHCP client port */
+	if (Connection != NULL)
+	{
+		uip_udp_appstate_t* const AppState = &Connection->appstate;
+		uip_udp_bind(Connection, HTONS(DHCPC_CLIENT_PORT));
+		
+		/* Set the initial client state */
+		AppState->DHCPClient.CurrentState = DHCP_STATE_SendDiscover;
+
+		/* Set timeout period to half a second for a DHCP server to respond */
+		timer_set(&AppState->DHCPClient.Timeout, CLOCK_SECOND / 2);
+	}
+}
+ 
+/** uIP stack application callback for the DHCP client. This function must be called each time the TCP/IP stack 
+ *  needs a UDP packet to be processed.
+ */
+void DHCPClientApp_Callback(void)
+{
+	uip_udp_appstate_t* const AppState    = &uip_udp_conn->appstate;
+	DHCP_Header_t*      const AppData     = (DHCP_Header_t*)uip_appdata;
+	uint16_t                  AppDataSize = 0;
+	
+	switch (AppState->DHCPClient.CurrentState)
+	{
+		case DHCP_STATE_SendDiscover:
+			/* Clear all DHCP settings, reset client IP address */
+			memset(&AppState->DHCPClient.DHCPOffer_Data, 0x00, sizeof(AppState->DHCPClient.DHCPOffer_Data));
+			uip_sethostaddr((uip_ipaddr_t*)&AppState->DHCPClient.DHCPOffer_Data.AllocatedIP);
+
+			/* Fill out the DHCP response header */
+			AppDataSize += DHCPClientApp_FillDHCPHeader(AppData, DHCP_DISCOVER, AppState);
+			
+			/* Add the required DHCP options list to the packet */
+			uint8_t RequiredOptionList[] = {DHCP_OPTION_SUBNET_MASK, DHCP_OPTION_ROUTER, DHCP_OPTION_DNS_SERVER};
+			AppDataSize += DHCPClientApp_SetOption(AppData->Options, DHCP_OPTION_REQ_LIST, sizeof(RequiredOptionList),
+			                                       RequiredOptionList);			
+			
+			/* Send the DHCP DISCOVER packet */
+			uip_udp_send(AppDataSize);
+
+			/* Reset the timeout timer, progress to next state */
+			timer_reset(&AppState->DHCPClient.Timeout);
+			AppState->DHCPClient.CurrentState = DHCP_STATE_WaitForOffer;			
+			
+			break;
+		case DHCP_STATE_WaitForOffer:
+			if (!(uip_newdata()))
+			{
+				/* Check if the DHCP timeout period has expired while waiting for a response */
+				if (timer_expired(&AppState->DHCPClient.Timeout))
+				  AppState->DHCPClient.CurrentState = DHCP_STATE_SendDiscover;
+				
+				break;
+			}
+			  
+			uint8_t OfferResponse_MessageType;
+			if ((AppData->TransactionID == DHCP_TRANSACTION_ID) &&
+			    DHCPClientApp_GetOption(AppData->Options, DHCP_OPTION_MSG_TYPE, &OfferResponse_MessageType) &&
+			    (OfferResponse_MessageType == DHCP_OFFER))
+			{
+				/* Received a DHCP offer for an IP address, copy over values for later request */
+				memcpy(&AppState->DHCPClient.DHCPOffer_Data.AllocatedIP, &AppData->YourIP, sizeof(uip_ipaddr_t));
+				DHCPClientApp_GetOption(AppData->Options, DHCP_OPTION_SUBNET_MASK, &AppState->DHCPClient.DHCPOffer_Data.Netmask);
+				DHCPClientApp_GetOption(AppData->Options, DHCP_OPTION_ROUTER,      &AppState->DHCPClient.DHCPOffer_Data.GatewayIP);
+				DHCPClientApp_GetOption(AppData->Options, DHCP_OPTION_SERVER_ID,   &AppState->DHCPClient.DHCPOffer_Data.ServerIP);
+				
+				timer_reset(&AppState->DHCPClient.Timeout);
+				AppState->DHCPClient.CurrentState = DHCP_STATE_SendRequest;
+			}
+
+			break;
+		case DHCP_STATE_SendRequest:
+			/* Fill out the DHCP response header */
+			AppDataSize += DHCPClientApp_FillDHCPHeader(AppData, DHCP_REQUEST, AppState);
+
+			/* Add the DHCP REQUESTED IP ADDRESS option to the packet */
+			AppDataSize += DHCPClientApp_SetOption(AppData->Options, DHCP_OPTION_REQ_IPADDR, sizeof(uip_ipaddr_t),
+			                                       &AppState->DHCPClient.DHCPOffer_Data.AllocatedIP);
+
+			/* Add the DHCP SERVER IP ADDRESS option to the packet */
+			AppDataSize += DHCPClientApp_SetOption(AppData->Options, DHCP_OPTION_SERVER_ID, sizeof(uip_ipaddr_t),
+			                                       &AppState->DHCPClient.DHCPOffer_Data.ServerIP);
+
+			/* Send the DHCP REQUEST packet */
+			uip_udp_send(AppDataSize);
+			
+			/* Reset the timeout timer, progress to next state */
+			timer_reset(&AppState->DHCPClient.Timeout);
+			AppState->DHCPClient.CurrentState = DHCP_STATE_WaitForACK;
+
+			break;
+		case DHCP_STATE_WaitForACK:
+			if (!(uip_newdata()))
+			{
+				/* Check if the DHCP timeout period has expired while waiting for a response */
+				if (timer_expired(&AppState->DHCPClient.Timeout))
+				  AppState->DHCPClient.CurrentState = DHCP_STATE_SendDiscover;
+				
+				break;
+			}
+			
+			uint8_t RequestResponse_MessageType;
+			if ((AppData->TransactionID == DHCP_TRANSACTION_ID) &&
+			    DHCPClientApp_GetOption(AppData->Options, DHCP_OPTION_MSG_TYPE, &RequestResponse_MessageType) &&
+			    (RequestResponse_MessageType == DHCP_ACK))
+			{
+				/* Set the new network parameters from the DHCP server */
+				uip_sethostaddr((uip_ipaddr_t*)&AppState->DHCPClient.DHCPOffer_Data.AllocatedIP);
+				uip_setnetmask((uip_ipaddr_t*)&AppState->DHCPClient.DHCPOffer_Data.Netmask);
+				uip_setdraddr((uip_ipaddr_t*)&AppState->DHCPClient.DHCPOffer_Data.GatewayIP);
+			
+				/* Indicate to the user that we now have a valid IP configuration */
+				HaveIPConfiguration = true;
+
+				AppState->DHCPClient.CurrentState = DHCP_STATE_AddressLeased;				
+			}
+			
+			break;
+	}
+}
+
+/** Fills the DHCP packet response with the appropriate BOOTP header for DHCP. This fills out all the required
+ *  fields, leaving only the additional DHCP options to be added to the packet before it is sent to the DHCP server.
+ *
+ *  \param[out] DHCPHeader  Location in the packet buffer where the BOOTP header should be written to
+ *  \param[in]  DHCPMessageType  DHCP Message type, such as DHCP_DISCOVER
+ *  \param[in]  AppState    Application state of the current UDP connection
+ *
+ *  \return Size in bytes of the created DHCP packet
+ */
+static uint16_t DHCPClientApp_FillDHCPHeader(DHCP_Header_t* const DHCPHeader, const uint8_t DHCPMessageType, uip_udp_appstate_t* AppState)
+{
+	/* Erase existing packet data so that we start will all 0x00 DHCP header data */
+ 	memset(DHCPHeader, 0, sizeof(DHCP_Header_t));
+
+	/* Fill out the DHCP packet header */
+	DHCPHeader->Operation             = DHCP_OP_BOOTREQUEST;
+	DHCPHeader->HardwareType          = DHCP_HTYPE_ETHERNET;
+	DHCPHeader->HardwareAddressLength = sizeof(MACAddress);
+	DHCPHeader->Hops                  = 0;
+	DHCPHeader->TransactionID         = DHCP_TRANSACTION_ID;
+	DHCPHeader->ElapsedSeconds        = 0;
+	DHCPHeader->Flags                 = HTONS(BOOTP_BROADCAST);
+	memcpy(&DHCPHeader->ClientIP,     &uip_hostaddr,        sizeof(uip_ipaddr_t));
+	memcpy(&DHCPHeader->YourIP,       &AppState->DHCPClient.DHCPOffer_Data.AllocatedIP, sizeof(uip_ipaddr_t));
+	memcpy(&DHCPHeader->NextServerIP, &AppState->DHCPClient.DHCPOffer_Data.ServerIP,    sizeof(uip_ipaddr_t));
+	memcpy(&DHCPHeader->ClientHardwareAddress, &MACAddress, sizeof(struct uip_eth_addr));
+	DHCPHeader->Cookie                = DHCP_MAGIC_COOKIE;
+	
+	/* Add a DHCP message type and terminator options to the start of the DHCP options field */
+	DHCPHeader->Options[0]            = DHCP_OPTION_MSG_TYPE;
+	DHCPHeader->Options[1]            = 1;
+	DHCPHeader->Options[2]            = DHCPMessageType;
+	DHCPHeader->Options[3]            = DHCP_OPTION_END;
+	
+	/* Calculate the total number of bytes added to the outgoing packet */
+	return (sizeof(DHCP_Header_t) + 4);
+}
+
+/** Sets the given DHCP option in the DHCP packet's option list. This automatically moves the
+ *  end of options terminator past the new option in the options list.
+ *
+ *  \param[in,out] DHCPOptionList  Pointer to the start of the DHCP packet's options list
+ *  \param[in]     Option          DHCP option to add to the list
+ *  \param[in]     DataLen         Size in bytes of the option data to add
+ *  \param[in]     OptionData      Buffer where the option's data is to be sourced from
+ *
+ *  \return Number of bytes added to the DHCP packet
+ */
+static uint8_t DHCPClientApp_SetOption(uint8_t* DHCPOptionList, uint8_t Option, uint8_t DataLen, void* OptionData)
+{
+	/* Skip through the DHCP options list until the terminator option is found */
+	while (*DHCPOptionList != DHCP_OPTION_END)
+	  DHCPOptionList += (DHCPOptionList[1] + 2);
+
+	/* Overwrite the existing terminator with the new option, add a new terminator at the end of the list */
+	DHCPOptionList[0] = Option;
+	DHCPOptionList[1] = DataLen;
+	memcpy(&DHCPOptionList[2], OptionData, DataLen);
+	DHCPOptionList[2 + DataLen] = DHCP_OPTION_END;
+	
+	/* Calculate the total number of bytes added to the outgoing packet */
+	return (2 + DataLen);
+}
+
+/** Retrieves the given option's data (if present) from the DHCP packet's options list.
+ *
+ *  \param[in,out] DHCPOptionList  Pointer to the start of the DHCP packet's options list
+ *  \param[in]     Option          DHCP option to retrieve to the list
+ *  \param[out]    Destination     Buffer where the option's data is to be written to if found
+ *
+ *  \return Boolean true if the option was found in the DHCP packet's options list, false otherwise
+ */
+static bool DHCPClientApp_GetOption(const uint8_t* DHCPOptionList, const uint8_t Option, void* const Destination)
+{
+	/* Look through the incoming DHCP packet's options list for the requested option */
+	while (*DHCPOptionList != DHCP_OPTION_END)
+	{
+		/* Check if the current DHCP option in the packet is the one requested */
+		if (DHCPOptionList[0] == Option)
+		{
+			/* Copy request option's data to the destination buffer */
+			memcpy(Destination, &DHCPOptionList[2], DHCPOptionList[1]);
+			
+			/* Indicate that the requested option data was successfully retrieved */
+			return true;
+		}
+		
+		/* Skip to next DHCP option in the options list */
+		DHCPOptionList += (DHCPOptionList[1] + 2);
+	}
+	
+	/* Requested option not found in the incoming packet's DHCP options list */
+	return false;
+}
+#endif
diff --git a/Projects/Webserver/Lib/DHCPClientApp.h b/Projects/Webserver/Lib/DHCPClientApp.h
index fc43f6be5..d52398325 100644
--- a/Projects/Webserver/Lib/DHCPClientApp.h
+++ b/Projects/Webserver/Lib/DHCPClientApp.h
@@ -1,169 +1,169 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-/** \file

- *

- *  Header file for DHCPClientApp.c.

- */

-

-#ifndef _DHCPCLIENT_APP_H_

-#define _DHCPCLIENT_APP_H_

-

-	/* Includes: */

-		#include <stdio.h>

-		

-		#include <uip.h>

-		

-		#include "../Webserver.h"

-		

-	/* Macros: */

-		/** UDP listen port for a BOOTP server */

-		#define DHCPC_SERVER_PORT         67

-

-		/** UDP listen port for a BOOTP client */

-		#define DHCPC_CLIENT_PORT         68

-

-		/** BOOTP message type for a BOOTP REQUEST message */

-		#define DHCP_OP_BOOTREQUEST       0x01

-

-		/** BOOTP message type for a BOOTP REPLY message */

-		#define DHCP_OP_BOOTREPLY         0x02

-

-		/** BOOTP flag for a BOOTP broadcast message */

-		#define BOOTP_BROADCAST           0x8000

-		

-		/** Magic DHCP cookie for a BOOTP message to identify it as a DHCP message */

-		#define DHCP_MAGIC_COOKIE         0x63538263

-		

-		/** Unique transaction ID used to identify DHCP responses to the client */

-		#define DHCP_TRANSACTION_ID       0x13245466

-

-		/** DHCP message type for a DISCOVER message */

-		#define DHCP_DISCOVER             1

-

-		/** DHCP message type for an OFFER message */

-		#define DHCP_OFFER                2

-

-		/** DHCP message type for a REQUEST message */

-		#define DHCP_REQUEST              3

-

-		/** DHCP message type for a DECLINE message */

-		#define DHCP_DECLINE              4

-

-		/** DHCP message type for an ACK message */

-		#define DHCP_ACK                  5

-

-		/** DHCP message type for a NAK message */

-		#define DHCP_NAK                  6

-

-		/** DHCP message type for a RELEASE message */

-		#define DHCP_RELEASE              7

-

-		/** DHCP medium type for standard Ethernet */

-		#define DHCP_HTYPE_ETHERNET       1

-

-		/** DHCP message option for the network subnet mask */

-		#define DHCP_OPTION_SUBNET_MASK   1

-

-		/** DHCP message option for the network gateway IP */

-		#define DHCP_OPTION_ROUTER        3

-

-		/** DHCP message option for the network DNS server */

-		#define DHCP_OPTION_DNS_SERVER    6

-

-		/** DHCP message option for the requested client IP address */

-		#define DHCP_OPTION_REQ_IPADDR    50

-

-		/** DHCP message option for the IP address lease time */

-		#define DHCP_OPTION_LEASE_TIME    51

-

-		/** DHCP message option for the DHCP message type */

-		#define DHCP_OPTION_MSG_TYPE      53

-		

-		/** DHCP message option for the DHCP server IP */		

-		#define DHCP_OPTION_SERVER_ID     54

-

-		/** DHCP message option for the list of required options from the server */

-		#define DHCP_OPTION_REQ_LIST      55

-

-		/** DHCP message option for the options list terminator */

-		#define DHCP_OPTION_END           255

-

-	/* Type Defines: */

-		/** Type define for a DHCP packet inside an Ethernet frame. */

-		typedef struct

-		{

-			uint8_t  Operation; /**< DHCP operation, either DHCP_OP_BOOTREQUEST or DHCP_OP_BOOTREPLY */

-			uint8_t  HardwareType; /**< Hardware carrier type constant */

-			uint8_t  HardwareAddressLength;  /**< Length in bytes of a hardware (MAC) address on the network */

-			uint8_t  Hops; /**< Number of hops required to reach the server, unused */

-

-			uint32_t TransactionID; /**< Unique ID of the DHCP packet, for positive matching between sent and received packets */

-

-			uint16_t ElapsedSeconds; /**< Elapsed seconds since the request was made */

-			uint16_t Flags; /**< BOOTP packet flags */

-			

-			uip_ipaddr_t ClientIP; /**< Client IP address, if already leased an IP */

-			uip_ipaddr_t YourIP; /**< Client IP address */

-			uip_ipaddr_t NextServerIP; /**< Legacy BOOTP protocol field, unused for DHCP */

-			uip_ipaddr_t RelayAgentIP; /**< Legacy BOOTP protocol field, unused for DHCP */

-			

-			uint8_t ClientHardwareAddress[16]; /**< Hardware (MAC) address of the client making a request to the DHCP server */

-			uint8_t ServerHostnameString[64]; /**< Legacy BOOTP protocol field, unused for DHCP */

-			uint8_t BootFileName[128]; /**< Legacy BOOTP protocol field, unused for DHCP */

-			

-			uint32_t Cookie; /**< Magic BOOTP protocol cookie to indicate a valid packet */

-			

-			uint8_t  Options[]; /** DHCP message options */

-		} DHCP_Header_t;

-

-	/* Enums: */

-		/** States for each DHCP connection to a DHCP client. */

-		enum DHCP_States_t

-		{

-			DHCP_STATE_SendDiscover,  /**< Send DISCOVER packet to retrieve DHCP lease offers */

-			DHCP_STATE_WaitForOffer,  /**< Waiting for OFFER packet giving available DHCP leases */

-			DHCP_STATE_SendRequest,   /**< Send REQUEST packet to request a DHCP lease */

-			DHCP_STATE_WaitForACK,    /**< Wait for ACK packet to complete the DHCP lease */

-			DHCP_STATE_AddressLeased, /**< DHCP address has been leased from a DHCP server */

-		};

-

-	/* Function Prototypes: */

-		void DHCPClientApp_Init(void);

-		void DHCPClientApp_Callback(void);

-		

-		#if defined(INCLUDE_FROM_DHCPCLIENTAPP_C)

-			static uint16_t DHCPClientApp_FillDHCPHeader(DHCP_Header_t* const DHCPHeader, const uint8_t DHCPMessageType,

-			                                             uip_udp_appstate_t* AppState);

-			static uint8_t  DHCPClientApp_SetOption(uint8_t* DHCPOptionList, uint8_t Option, uint8_t DataLen,

-			                                        void* OptionData);

-			static bool     DHCPClientApp_GetOption(const uint8_t* DHCPOptionList, const uint8_t Option, void* const Destination);

-		#endif

-#endif

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  Header file for DHCPClientApp.c.
+ */
+
+#ifndef _DHCPCLIENT_APP_H_
+#define _DHCPCLIENT_APP_H_
+
+	/* Includes: */
+		#include <stdio.h>
+		
+		#include <uip.h>
+		
+		#include "../Webserver.h"
+		
+	/* Macros: */
+		/** UDP listen port for a BOOTP server */
+		#define DHCPC_SERVER_PORT         67
+
+		/** UDP listen port for a BOOTP client */
+		#define DHCPC_CLIENT_PORT         68
+
+		/** BOOTP message type for a BOOTP REQUEST message */
+		#define DHCP_OP_BOOTREQUEST       0x01
+
+		/** BOOTP message type for a BOOTP REPLY message */
+		#define DHCP_OP_BOOTREPLY         0x02
+
+		/** BOOTP flag for a BOOTP broadcast message */
+		#define BOOTP_BROADCAST           0x8000
+		
+		/** Magic DHCP cookie for a BOOTP message to identify it as a DHCP message */
+		#define DHCP_MAGIC_COOKIE         0x63538263
+		
+		/** Unique transaction ID used to identify DHCP responses to the client */
+		#define DHCP_TRANSACTION_ID       0x13245466
+
+		/** DHCP message type for a DISCOVER message */
+		#define DHCP_DISCOVER             1
+
+		/** DHCP message type for an OFFER message */
+		#define DHCP_OFFER                2
+
+		/** DHCP message type for a REQUEST message */
+		#define DHCP_REQUEST              3
+
+		/** DHCP message type for a DECLINE message */
+		#define DHCP_DECLINE              4
+
+		/** DHCP message type for an ACK message */
+		#define DHCP_ACK                  5
+
+		/** DHCP message type for a NAK message */
+		#define DHCP_NAK                  6
+
+		/** DHCP message type for a RELEASE message */
+		#define DHCP_RELEASE              7
+
+		/** DHCP medium type for standard Ethernet */
+		#define DHCP_HTYPE_ETHERNET       1
+
+		/** DHCP message option for the network subnet mask */
+		#define DHCP_OPTION_SUBNET_MASK   1
+
+		/** DHCP message option for the network gateway IP */
+		#define DHCP_OPTION_ROUTER        3
+
+		/** DHCP message option for the network DNS server */
+		#define DHCP_OPTION_DNS_SERVER    6
+
+		/** DHCP message option for the requested client IP address */
+		#define DHCP_OPTION_REQ_IPADDR    50
+
+		/** DHCP message option for the IP address lease time */
+		#define DHCP_OPTION_LEASE_TIME    51
+
+		/** DHCP message option for the DHCP message type */
+		#define DHCP_OPTION_MSG_TYPE      53
+		
+		/** DHCP message option for the DHCP server IP */		
+		#define DHCP_OPTION_SERVER_ID     54
+
+		/** DHCP message option for the list of required options from the server */
+		#define DHCP_OPTION_REQ_LIST      55
+
+		/** DHCP message option for the options list terminator */
+		#define DHCP_OPTION_END           255
+
+	/* Type Defines: */
+		/** Type define for a DHCP packet inside an Ethernet frame. */
+		typedef struct
+		{
+			uint8_t  Operation; /**< DHCP operation, either DHCP_OP_BOOTREQUEST or DHCP_OP_BOOTREPLY */
+			uint8_t  HardwareType; /**< Hardware carrier type constant */
+			uint8_t  HardwareAddressLength;  /**< Length in bytes of a hardware (MAC) address on the network */
+			uint8_t  Hops; /**< Number of hops required to reach the server, unused */
+
+			uint32_t TransactionID; /**< Unique ID of the DHCP packet, for positive matching between sent and received packets */
+
+			uint16_t ElapsedSeconds; /**< Elapsed seconds since the request was made */
+			uint16_t Flags; /**< BOOTP packet flags */
+			
+			uip_ipaddr_t ClientIP; /**< Client IP address, if already leased an IP */
+			uip_ipaddr_t YourIP; /**< Client IP address */
+			uip_ipaddr_t NextServerIP; /**< Legacy BOOTP protocol field, unused for DHCP */
+			uip_ipaddr_t RelayAgentIP; /**< Legacy BOOTP protocol field, unused for DHCP */
+			
+			uint8_t ClientHardwareAddress[16]; /**< Hardware (MAC) address of the client making a request to the DHCP server */
+			uint8_t ServerHostnameString[64]; /**< Legacy BOOTP protocol field, unused for DHCP */
+			uint8_t BootFileName[128]; /**< Legacy BOOTP protocol field, unused for DHCP */
+			
+			uint32_t Cookie; /**< Magic BOOTP protocol cookie to indicate a valid packet */
+			
+			uint8_t  Options[]; /** DHCP message options */
+		} DHCP_Header_t;
+
+	/* Enums: */
+		/** States for each DHCP connection to a DHCP client. */
+		enum DHCP_States_t
+		{
+			DHCP_STATE_SendDiscover,  /**< Send DISCOVER packet to retrieve DHCP lease offers */
+			DHCP_STATE_WaitForOffer,  /**< Waiting for OFFER packet giving available DHCP leases */
+			DHCP_STATE_SendRequest,   /**< Send REQUEST packet to request a DHCP lease */
+			DHCP_STATE_WaitForACK,    /**< Wait for ACK packet to complete the DHCP lease */
+			DHCP_STATE_AddressLeased, /**< DHCP address has been leased from a DHCP server */
+		};
+
+	/* Function Prototypes: */
+		void DHCPClientApp_Init(void);
+		void DHCPClientApp_Callback(void);
+		
+		#if defined(INCLUDE_FROM_DHCPCLIENTAPP_C)
+			static uint16_t DHCPClientApp_FillDHCPHeader(DHCP_Header_t* const DHCPHeader, const uint8_t DHCPMessageType,
+			                                             uip_udp_appstate_t* AppState);
+			static uint8_t  DHCPClientApp_SetOption(uint8_t* DHCPOptionList, uint8_t Option, uint8_t DataLen,
+			                                        void* OptionData);
+			static bool     DHCPClientApp_GetOption(const uint8_t* DHCPOptionList, const uint8_t Option, void* const Destination);
+		#endif
+#endif
diff --git a/Projects/Webserver/Lib/DataflashManager.c b/Projects/Webserver/Lib/DataflashManager.c
index da57e7f49..48c4fa7e6 100644
--- a/Projects/Webserver/Lib/DataflashManager.c
+++ b/Projects/Webserver/Lib/DataflashManager.c
@@ -1,525 +1,525 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-/** \file

- *

- *  Functions to manage the physical dataflash media, including reading and writing of

- *  blocks of data. These functions are called by the SCSI layer when data must be stored

- *  or retrieved to/from the physical storage media. If a different media is used (such

- *  as a SD card or EEPROM), functions similar to these will need to be generated.

- */

-

-#define  INCLUDE_FROM_DATAFLASHMANAGER_C

-#include "DataflashManager.h"

-

-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from

- *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes

- *  them to the dataflash in Dataflash page sized blocks.

- *

- *  \param[in] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state

- *  \param[in] BlockAddress  Data block starting address for the write sequence

- *  \param[in] TotalBlocks   Number of blocks of data to write

- */

-void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)

-{

-	uint16_t CurrDFPage          = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);

-	uint16_t CurrDFPageByte      = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);

-	uint8_t  CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);

-	bool     UsingSecondBuffer   = false;

-

-	/* Select the correct starting Dataflash IC for the block requested */

-	Dataflash_SelectChipFromPage(CurrDFPage);

-

-#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)

-	/* Copy selected dataflash's current page contents to the dataflash buffer */

-	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);

-	Dataflash_SendAddressBytes(CurrDFPage, 0);

-	Dataflash_WaitWhileBusy();

-#endif

-

-	/* Send the dataflash buffer write command */

-	Dataflash_SendByte(DF_CMD_BUFF1WRITE);

-	Dataflash_SendAddressBytes(0, CurrDFPageByte);

-

-	/* Wait until endpoint is ready before continuing */

-	if (Endpoint_WaitUntilReady())

-	  return;

-

-	while (TotalBlocks)

-	{

-		uint8_t BytesInBlockDiv16 = 0;

-		

-		/* Write an endpoint packet sized data block to the dataflash */

-		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))

-		{

-			/* Check if the endpoint is currently empty */

-			if (!(Endpoint_IsReadWriteAllowed()))

-			{

-				/* Clear the current endpoint bank */

-				Endpoint_ClearOUT();

-				

-				/* Wait until the host has sent another packet */

-				if (Endpoint_WaitUntilReady())

-				  return;

-			}

-

-			/* Check if end of dataflash page reached */

-			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))

-			{

-				/* Write the dataflash buffer contents back to the dataflash page */

-				Dataflash_WaitWhileBusy();

-				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);

-				Dataflash_SendAddressBytes(CurrDFPage, 0);

-

-				/* Reset the dataflash buffer counter, increment the page counter */

-				CurrDFPageByteDiv16 = 0;

-				CurrDFPage++;

-

-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */

-				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))

-				  UsingSecondBuffer = !(UsingSecondBuffer);

-

-				/* Select the next dataflash chip based on the new dataflash page index */

-				Dataflash_SelectChipFromPage(CurrDFPage);

-

-#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)

-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */

-				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))

-				{

-					/* Copy selected dataflash's current page contents to the dataflash buffer */

-					Dataflash_WaitWhileBusy();

-					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);

-					Dataflash_SendAddressBytes(CurrDFPage, 0);

-					Dataflash_WaitWhileBusy();

-				}

-#endif

-

-				/* Send the dataflash buffer write command */

-				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2WRITE : DF_CMD_BUFF1WRITE);

-				Dataflash_SendAddressBytes(0, 0);				

-			}

-

-			/* Write one 16-byte chunk of data to the dataflash */

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			Dataflash_SendByte(Endpoint_Read_Byte());

-			

-			/* Increment the dataflash page 16 byte block counter */

-			CurrDFPageByteDiv16++;

-

-			/* Increment the block 16 byte block counter */

-			BytesInBlockDiv16++;

-

-			/* Check if the current command is being aborted by the host */

-			if (MSInterfaceInfo->State.IsMassStoreReset)

-			  return;			

-		}

-			

-		/* Decrement the blocks remaining counter and reset the sub block counter */

-		TotalBlocks--;

-	}

-

-	/* Write the dataflash buffer contents back to the dataflash page */

-	Dataflash_WaitWhileBusy();

-	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);

-	Dataflash_SendAddressBytes(CurrDFPage, 0x00);

-	Dataflash_WaitWhileBusy();

-

-	/* If the endpoint is empty, clear it ready for the next packet from the host */

-	if (!(Endpoint_IsReadWriteAllowed()))

-	  Endpoint_ClearOUT();

-

-	/* Deselect all dataflash chips */

-	Dataflash_DeselectChip();

-}

-

-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into

- *  the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash

- *  and writes them in OS sized blocks to the endpoint.

- *

- *  \param[in] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state

- *  \param[in] BlockAddress  Data block starting address for the read sequence

- *  \param[in] TotalBlocks   Number of blocks of data to read

- */

-void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)

-{

-	uint16_t CurrDFPage          = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);

-	uint16_t CurrDFPageByte      = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);

-	uint8_t  CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);

-

-	/* Select the correct starting Dataflash IC for the block requested */

-	Dataflash_SelectChipFromPage(CurrDFPage);

-

-	/* Send the dataflash main memory page read command */

-	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);

-	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);

-	Dataflash_SendByte(0x00);

-	Dataflash_SendByte(0x00);

-	Dataflash_SendByte(0x00);

-	Dataflash_SendByte(0x00);

-	

-	/* Wait until endpoint is ready before continuing */

-	if (Endpoint_WaitUntilReady())

-	  return;

-	

-	while (TotalBlocks)

-	{

-		uint8_t BytesInBlockDiv16 = 0;

-		

-		/* Write an endpoint packet sized data block to the dataflash */

-		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))

-		{

-			/* Check if the endpoint is currently full */

-			if (!(Endpoint_IsReadWriteAllowed()))

-			{

-				/* Clear the endpoint bank to send its contents to the host */

-				Endpoint_ClearIN();

-				

-				/* Wait until the endpoint is ready for more data */

-				if (Endpoint_WaitUntilReady())

-				  return;

-			}

-			

-			/* Check if end of dataflash page reached */

-			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))

-			{

-				/* Reset the dataflash buffer counter, increment the page counter */

-				CurrDFPageByteDiv16 = 0;

-				CurrDFPage++;

-

-				/* Select the next dataflash chip based on the new dataflash page index */

-				Dataflash_SelectChipFromPage(CurrDFPage);

-				

-				/* Send the dataflash main memory page read command */

-				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);

-				Dataflash_SendAddressBytes(CurrDFPage, 0);

-				Dataflash_SendByte(0x00);

-				Dataflash_SendByte(0x00);

-				Dataflash_SendByte(0x00);

-				Dataflash_SendByte(0x00);

-			}	

-

-			/* Read one 16-byte chunk of data from the dataflash */

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			Endpoint_Write_Byte(Dataflash_ReceiveByte());

-			

-			/* Increment the dataflash page 16 byte block counter */

-			CurrDFPageByteDiv16++;

-			

-			/* Increment the block 16 byte block counter */

-			BytesInBlockDiv16++;

-

-			/* Check if the current command is being aborted by the host */

-			if (MSInterfaceInfo->State.IsMassStoreReset)

-			  return;

-		}

-		

-		/* Decrement the blocks remaining counter */

-		TotalBlocks--;

-	}

-	

-	/* If the endpoint is full, send its contents to the host */

-	if (!(Endpoint_IsReadWriteAllowed()))

-	  Endpoint_ClearIN();

-

-	/* Deselect all dataflash chips */

-	Dataflash_DeselectChip();

-}

-

-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from

- *  the a given RAM buffer. This routine reads in OS sized blocks from the buffer and writes them to the

- *  dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the

- *  dataflash.

- *

- *  \param[in] BlockAddress  Data block starting address for the write sequence

- *  \param[in] TotalBlocks   Number of blocks of data to write

- *  \param[in] BufferPtr     Pointer to the data source RAM buffer

- */

-void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, const uint8_t* BufferPtr)

-{

-	uint16_t CurrDFPage          = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);

-	uint16_t CurrDFPageByte      = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);

-	uint8_t  CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);

-	bool     UsingSecondBuffer   = false;

-

-	/* Select the correct starting Dataflash IC for the block requested */

-	Dataflash_SelectChipFromPage(CurrDFPage);

-

-#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)

-	/* Copy selected dataflash's current page contents to the dataflash buffer */

-	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);

-	Dataflash_SendAddressBytes(CurrDFPage, 0);

-	Dataflash_WaitWhileBusy();

-#endif

-

-	/* Send the dataflash buffer write command */

-	Dataflash_SendByte(DF_CMD_BUFF1WRITE);

-	Dataflash_SendAddressBytes(0, CurrDFPageByte);

-	

-	while (TotalBlocks)

-	{

-		uint8_t BytesInBlockDiv16 = 0;

-		

-		/* Write an endpoint packet sized data block to the dataflash */

-		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))

-		{

-			/* Check if end of dataflash page reached */

-			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))

-			{

-				/* Write the dataflash buffer contents back to the dataflash page */

-				Dataflash_WaitWhileBusy();

-				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);

-				Dataflash_SendAddressBytes(CurrDFPage, 0);

-

-				/* Reset the dataflash buffer counter, increment the page counter */

-				CurrDFPageByteDiv16 = 0;

-				CurrDFPage++;

-

-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */

-				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))

-				  UsingSecondBuffer = !(UsingSecondBuffer);

-

-				/* Select the next dataflash chip based on the new dataflash page index */

-				Dataflash_SelectChipFromPage(CurrDFPage);

-

-#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)

-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */

-				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))

-				{

-					/* Copy selected dataflash's current page contents to the dataflash buffer */

-					Dataflash_WaitWhileBusy();

-					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);

-					Dataflash_SendAddressBytes(CurrDFPage, 0);

-					Dataflash_WaitWhileBusy();

-				}

-#endif

-

-				/* Send the dataflash buffer write command */

-				Dataflash_ToggleSelectedChipCS();

-				Dataflash_SendByte(DF_CMD_BUFF1WRITE);

-				Dataflash_SendAddressBytes(0, 0);

-			}

-			

-			/* Write one 16-byte chunk of data to the dataflash */

-			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)

-			  Dataflash_SendByte(*(BufferPtr++));

-			

-			/* Increment the dataflash page 16 byte block counter */

-			CurrDFPageByteDiv16++;

-

-			/* Increment the block 16 byte block counter */

-			BytesInBlockDiv16++;		

-		}

-			

-		/* Decrement the blocks remaining counter and reset the sub block counter */

-		TotalBlocks--;

-	}

-

-	/* Write the dataflash buffer contents back to the dataflash page */

-	Dataflash_WaitWhileBusy();

-	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);

-	Dataflash_SendAddressBytes(CurrDFPage, 0x00);

-	Dataflash_WaitWhileBusy();

-

-	/* Deselect all dataflash chips */

-	Dataflash_DeselectChip();

-}

-

-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into

- *  the a preallocated RAM buffer. This routine reads in Dataflash page sized blocks from the Dataflash

- *  and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read

- *  the files stored on the dataflash.

- *

- *  \param[in] BlockAddress  Data block starting address for the read sequence

- *  \param[in] TotalBlocks   Number of blocks of data to read

- *  \param[out] BufferPtr    Pointer to the data destination RAM buffer

- */

-void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)

-{

-	uint16_t CurrDFPage          = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);

-	uint16_t CurrDFPageByte      = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);

-	uint8_t  CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);

-

-	/* Select the correct starting Dataflash IC for the block requested */

-	Dataflash_SelectChipFromPage(CurrDFPage);

-

-	/* Send the dataflash main memory page read command */

-	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);

-	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);

-	Dataflash_SendByte(0x00);

-	Dataflash_SendByte(0x00);

-	Dataflash_SendByte(0x00);

-	Dataflash_SendByte(0x00);

-

-	while (TotalBlocks)

-	{

-		uint8_t BytesInBlockDiv16 = 0;

-		

-		/* Write an endpoint packet sized data block to the dataflash */

-		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))

-		{

-			/* Check if end of dataflash page reached */

-			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))

-			{

-				/* Reset the dataflash buffer counter, increment the page counter */

-				CurrDFPageByteDiv16 = 0;

-				CurrDFPage++;

-

-				/* Select the next dataflash chip based on the new dataflash page index */

-				Dataflash_SelectChipFromPage(CurrDFPage);

-				

-				/* Send the dataflash main memory page read command */

-				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);

-				Dataflash_SendAddressBytes(CurrDFPage, 0);

-				Dataflash_SendByte(0x00);

-				Dataflash_SendByte(0x00);

-				Dataflash_SendByte(0x00);

-				Dataflash_SendByte(0x00);

-			}	

-

-			/* Read one 16-byte chunk of data from the dataflash */

-			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)

-			  *(BufferPtr++) = Dataflash_ReceiveByte();

-			

-			/* Increment the dataflash page 16 byte block counter */

-			CurrDFPageByteDiv16++;

-			

-			/* Increment the block 16 byte block counter */

-			BytesInBlockDiv16++;

-		}

-		

-		/* Decrement the blocks remaining counter */

-		TotalBlocks--;

-	}

-

-	/* Deselect all dataflash chips */

-	Dataflash_DeselectChip();

-}

-

-/** Disables the dataflash memory write protection bits on the board Dataflash ICs, if enabled. */

-void DataflashManager_ResetDataflashProtections(void)

-{

-	/* Select first dataflash chip, send the read status register command */

-	Dataflash_SelectChip(DATAFLASH_CHIP1);

-	Dataflash_SendByte(DF_CMD_GETSTATUS);

-	

-	/* Check if sector protection is enabled */

-	if (Dataflash_ReceiveByte() & DF_STATUS_SECTORPROTECTION_ON)

-	{

-		Dataflash_ToggleSelectedChipCS();

-

-		/* Send the commands to disable sector protection */

-		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[0]);

-		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[1]);

-		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[2]);

-		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);

-	}

-	

-	/* Select second dataflash chip (if present on selected board), send read status register command */

-	#if (DATAFLASH_TOTALCHIPS == 2)

-	Dataflash_SelectChip(DATAFLASH_CHIP2);

-	Dataflash_SendByte(DF_CMD_GETSTATUS);

-	

-	/* Check if sector protection is enabled */

-	if (Dataflash_ReceiveByte() & DF_STATUS_SECTORPROTECTION_ON)

-	{

-		Dataflash_ToggleSelectedChipCS();

-

-		/* Send the commands to disable sector protection */

-		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[0]);

-		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[1]);

-		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[2]);

-		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);

-	}

-	#endif

-	

-	/* Deselect current dataflash chip */

-	Dataflash_DeselectChip();

-}

-

-/** Performs a simple test on the attached Dataflash IC(s) to ensure that they are working.

- *

- *  \return Boolean true if all media chips are working, false otherwise

- */

-bool DataflashManager_CheckDataflashOperation(void)

-{

-	uint8_t ReturnByte;

-

-	/* Test first Dataflash IC is present and responding to commands */

-	Dataflash_SelectChip(DATAFLASH_CHIP1);

-	Dataflash_SendByte(DF_CMD_READMANUFACTURERDEVICEINFO);

-	ReturnByte = Dataflash_ReceiveByte();

-	Dataflash_DeselectChip();

-

-	/* If returned data is invalid, fail the command */

-	if (ReturnByte != DF_MANUFACTURER_ATMEL)

-	  return false;

-

-	#if (DATAFLASH_TOTALCHIPS == 2)

-	/* Test second Dataflash IC is present and responding to commands */

-	Dataflash_SelectChip(DATAFLASH_CHIP2);

-	Dataflash_SendByte(DF_CMD_READMANUFACTURERDEVICEINFO);

-	ReturnByte = Dataflash_ReceiveByte();

-	Dataflash_DeselectChip();

-

-	/* If returned data is invalid, fail the command */

-	if (ReturnByte != DF_MANUFACTURER_ATMEL)

-	  return false;

-	#endif

-	

-	return true;

-}

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  Functions to manage the physical dataflash media, including reading and writing of
+ *  blocks of data. These functions are called by the SCSI layer when data must be stored
+ *  or retrieved to/from the physical storage media. If a different media is used (such
+ *  as a SD card or EEPROM), functions similar to these will need to be generated.
+ */
+
+#define  INCLUDE_FROM_DATAFLASHMANAGER_C
+#include "DataflashManager.h"
+
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+ *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes
+ *  them to the dataflash in Dataflash page sized blocks.
+ *
+ *  \param[in] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state
+ *  \param[in] BlockAddress  Data block starting address for the write sequence
+ *  \param[in] TotalBlocks   Number of blocks of data to write
+ */
+void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)
+{
+	uint16_t CurrDFPage          = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
+	uint16_t CurrDFPageByte      = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);
+	uint8_t  CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);
+	bool     UsingSecondBuffer   = false;
+
+	/* Select the correct starting Dataflash IC for the block requested */
+	Dataflash_SelectChipFromPage(CurrDFPage);
+
+#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
+	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
+	Dataflash_SendAddressBytes(CurrDFPage, 0);
+	Dataflash_WaitWhileBusy();
+#endif
+
+	/* Send the dataflash buffer write command */
+	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
+	Dataflash_SendAddressBytes(0, CurrDFPageByte);
+
+	/* Wait until endpoint is ready before continuing */
+	if (Endpoint_WaitUntilReady())
+	  return;
+
+	while (TotalBlocks)
+	{
+		uint8_t BytesInBlockDiv16 = 0;
+		
+		/* Write an endpoint packet sized data block to the dataflash */
+		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
+		{
+			/* Check if the endpoint is currently empty */
+			if (!(Endpoint_IsReadWriteAllowed()))
+			{
+				/* Clear the current endpoint bank */
+				Endpoint_ClearOUT();
+				
+				/* Wait until the host has sent another packet */
+				if (Endpoint_WaitUntilReady())
+				  return;
+			}
+
+			/* Check if end of dataflash page reached */
+			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
+			{
+				/* Write the dataflash buffer contents back to the dataflash page */
+				Dataflash_WaitWhileBusy();
+				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
+				Dataflash_SendAddressBytes(CurrDFPage, 0);
+
+				/* Reset the dataflash buffer counter, increment the page counter */
+				CurrDFPageByteDiv16 = 0;
+				CurrDFPage++;
+
+				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
+				  UsingSecondBuffer = !(UsingSecondBuffer);
+
+				/* Select the next dataflash chip based on the new dataflash page index */
+				Dataflash_SelectChipFromPage(CurrDFPage);
+
+#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
+				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
+				{
+					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					Dataflash_WaitWhileBusy();
+					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
+					Dataflash_SendAddressBytes(CurrDFPage, 0);
+					Dataflash_WaitWhileBusy();
+				}
+#endif
+
+				/* Send the dataflash buffer write command */
+				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2WRITE : DF_CMD_BUFF1WRITE);
+				Dataflash_SendAddressBytes(0, 0);				
+			}
+
+			/* Write one 16-byte chunk of data to the dataflash */
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			Dataflash_SendByte(Endpoint_Read_Byte());
+			
+			/* Increment the dataflash page 16 byte block counter */
+			CurrDFPageByteDiv16++;
+
+			/* Increment the block 16 byte block counter */
+			BytesInBlockDiv16++;
+
+			/* Check if the current command is being aborted by the host */
+			if (MSInterfaceInfo->State.IsMassStoreReset)
+			  return;			
+		}
+			
+		/* Decrement the blocks remaining counter and reset the sub block counter */
+		TotalBlocks--;
+	}
+
+	/* Write the dataflash buffer contents back to the dataflash page */
+	Dataflash_WaitWhileBusy();
+	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
+	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
+	Dataflash_WaitWhileBusy();
+
+	/* If the endpoint is empty, clear it ready for the next packet from the host */
+	if (!(Endpoint_IsReadWriteAllowed()))
+	  Endpoint_ClearOUT();
+
+	/* Deselect all dataflash chips */
+	Dataflash_DeselectChip();
+}
+
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+ *  the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash
+ *  and writes them in OS sized blocks to the endpoint.
+ *
+ *  \param[in] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state
+ *  \param[in] BlockAddress  Data block starting address for the read sequence
+ *  \param[in] TotalBlocks   Number of blocks of data to read
+ */
+void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)
+{
+	uint16_t CurrDFPage          = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
+	uint16_t CurrDFPageByte      = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);
+	uint8_t  CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);
+
+	/* Select the correct starting Dataflash IC for the block requested */
+	Dataflash_SelectChipFromPage(CurrDFPage);
+
+	/* Send the dataflash main memory page read command */
+	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
+	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
+	Dataflash_SendByte(0x00);
+	Dataflash_SendByte(0x00);
+	Dataflash_SendByte(0x00);
+	Dataflash_SendByte(0x00);
+	
+	/* Wait until endpoint is ready before continuing */
+	if (Endpoint_WaitUntilReady())
+	  return;
+	
+	while (TotalBlocks)
+	{
+		uint8_t BytesInBlockDiv16 = 0;
+		
+		/* Write an endpoint packet sized data block to the dataflash */
+		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
+		{
+			/* Check if the endpoint is currently full */
+			if (!(Endpoint_IsReadWriteAllowed()))
+			{
+				/* Clear the endpoint bank to send its contents to the host */
+				Endpoint_ClearIN();
+				
+				/* Wait until the endpoint is ready for more data */
+				if (Endpoint_WaitUntilReady())
+				  return;
+			}
+			
+			/* Check if end of dataflash page reached */
+			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
+			{
+				/* Reset the dataflash buffer counter, increment the page counter */
+				CurrDFPageByteDiv16 = 0;
+				CurrDFPage++;
+
+				/* Select the next dataflash chip based on the new dataflash page index */
+				Dataflash_SelectChipFromPage(CurrDFPage);
+				
+				/* Send the dataflash main memory page read command */
+				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
+				Dataflash_SendAddressBytes(CurrDFPage, 0);
+				Dataflash_SendByte(0x00);
+				Dataflash_SendByte(0x00);
+				Dataflash_SendByte(0x00);
+				Dataflash_SendByte(0x00);
+			}	
+
+			/* Read one 16-byte chunk of data from the dataflash */
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			Endpoint_Write_Byte(Dataflash_ReceiveByte());
+			
+			/* Increment the dataflash page 16 byte block counter */
+			CurrDFPageByteDiv16++;
+			
+			/* Increment the block 16 byte block counter */
+			BytesInBlockDiv16++;
+
+			/* Check if the current command is being aborted by the host */
+			if (MSInterfaceInfo->State.IsMassStoreReset)
+			  return;
+		}
+		
+		/* Decrement the blocks remaining counter */
+		TotalBlocks--;
+	}
+	
+	/* If the endpoint is full, send its contents to the host */
+	if (!(Endpoint_IsReadWriteAllowed()))
+	  Endpoint_ClearIN();
+
+	/* Deselect all dataflash chips */
+	Dataflash_DeselectChip();
+}
+
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+ *  the a given RAM buffer. This routine reads in OS sized blocks from the buffer and writes them to the
+ *  dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
+ *  dataflash.
+ *
+ *  \param[in] BlockAddress  Data block starting address for the write sequence
+ *  \param[in] TotalBlocks   Number of blocks of data to write
+ *  \param[in] BufferPtr     Pointer to the data source RAM buffer
+ */
+void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, const uint8_t* BufferPtr)
+{
+	uint16_t CurrDFPage          = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
+	uint16_t CurrDFPageByte      = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);
+	uint8_t  CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);
+	bool     UsingSecondBuffer   = false;
+
+	/* Select the correct starting Dataflash IC for the block requested */
+	Dataflash_SelectChipFromPage(CurrDFPage);
+
+#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
+	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
+	Dataflash_SendAddressBytes(CurrDFPage, 0);
+	Dataflash_WaitWhileBusy();
+#endif
+
+	/* Send the dataflash buffer write command */
+	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
+	Dataflash_SendAddressBytes(0, CurrDFPageByte);
+	
+	while (TotalBlocks)
+	{
+		uint8_t BytesInBlockDiv16 = 0;
+		
+		/* Write an endpoint packet sized data block to the dataflash */
+		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
+		{
+			/* Check if end of dataflash page reached */
+			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
+			{
+				/* Write the dataflash buffer contents back to the dataflash page */
+				Dataflash_WaitWhileBusy();
+				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
+				Dataflash_SendAddressBytes(CurrDFPage, 0);
+
+				/* Reset the dataflash buffer counter, increment the page counter */
+				CurrDFPageByteDiv16 = 0;
+				CurrDFPage++;
+
+				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
+				  UsingSecondBuffer = !(UsingSecondBuffer);
+
+				/* Select the next dataflash chip based on the new dataflash page index */
+				Dataflash_SelectChipFromPage(CurrDFPage);
+
+#if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
+				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
+				{
+					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					Dataflash_WaitWhileBusy();
+					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
+					Dataflash_SendAddressBytes(CurrDFPage, 0);
+					Dataflash_WaitWhileBusy();
+				}
+#endif
+
+				/* Send the dataflash buffer write command */
+				Dataflash_ToggleSelectedChipCS();
+				Dataflash_SendByte(DF_CMD_BUFF1WRITE);
+				Dataflash_SendAddressBytes(0, 0);
+			}
+			
+			/* Write one 16-byte chunk of data to the dataflash */
+			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
+			  Dataflash_SendByte(*(BufferPtr++));
+			
+			/* Increment the dataflash page 16 byte block counter */
+			CurrDFPageByteDiv16++;
+
+			/* Increment the block 16 byte block counter */
+			BytesInBlockDiv16++;		
+		}
+			
+		/* Decrement the blocks remaining counter and reset the sub block counter */
+		TotalBlocks--;
+	}
+
+	/* Write the dataflash buffer contents back to the dataflash page */
+	Dataflash_WaitWhileBusy();
+	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
+	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
+	Dataflash_WaitWhileBusy();
+
+	/* Deselect all dataflash chips */
+	Dataflash_DeselectChip();
+}
+
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+ *  the a preallocated RAM buffer. This routine reads in Dataflash page sized blocks from the Dataflash
+ *  and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read
+ *  the files stored on the dataflash.
+ *
+ *  \param[in] BlockAddress  Data block starting address for the read sequence
+ *  \param[in] TotalBlocks   Number of blocks of data to read
+ *  \param[out] BufferPtr    Pointer to the data destination RAM buffer
+ */
+void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)
+{
+	uint16_t CurrDFPage          = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
+	uint16_t CurrDFPageByte      = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);
+	uint8_t  CurrDFPageByteDiv16 = (CurrDFPageByte >> 4);
+
+	/* Select the correct starting Dataflash IC for the block requested */
+	Dataflash_SelectChipFromPage(CurrDFPage);
+
+	/* Send the dataflash main memory page read command */
+	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
+	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
+	Dataflash_SendByte(0x00);
+	Dataflash_SendByte(0x00);
+	Dataflash_SendByte(0x00);
+	Dataflash_SendByte(0x00);
+
+	while (TotalBlocks)
+	{
+		uint8_t BytesInBlockDiv16 = 0;
+		
+		/* Write an endpoint packet sized data block to the dataflash */
+		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
+		{
+			/* Check if end of dataflash page reached */
+			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
+			{
+				/* Reset the dataflash buffer counter, increment the page counter */
+				CurrDFPageByteDiv16 = 0;
+				CurrDFPage++;
+
+				/* Select the next dataflash chip based on the new dataflash page index */
+				Dataflash_SelectChipFromPage(CurrDFPage);
+				
+				/* Send the dataflash main memory page read command */
+				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
+				Dataflash_SendAddressBytes(CurrDFPage, 0);
+				Dataflash_SendByte(0x00);
+				Dataflash_SendByte(0x00);
+				Dataflash_SendByte(0x00);
+				Dataflash_SendByte(0x00);
+			}	
+
+			/* Read one 16-byte chunk of data from the dataflash */
+			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
+			  *(BufferPtr++) = Dataflash_ReceiveByte();
+			
+			/* Increment the dataflash page 16 byte block counter */
+			CurrDFPageByteDiv16++;
+			
+			/* Increment the block 16 byte block counter */
+			BytesInBlockDiv16++;
+		}
+		
+		/* Decrement the blocks remaining counter */
+		TotalBlocks--;
+	}
+
+	/* Deselect all dataflash chips */
+	Dataflash_DeselectChip();
+}
+
+/** Disables the dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
+void DataflashManager_ResetDataflashProtections(void)
+{
+	/* Select first dataflash chip, send the read status register command */
+	Dataflash_SelectChip(DATAFLASH_CHIP1);
+	Dataflash_SendByte(DF_CMD_GETSTATUS);
+	
+	/* Check if sector protection is enabled */
+	if (Dataflash_ReceiveByte() & DF_STATUS_SECTORPROTECTION_ON)
+	{
+		Dataflash_ToggleSelectedChipCS();
+
+		/* Send the commands to disable sector protection */
+		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[0]);
+		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[1]);
+		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[2]);
+		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
+	}
+	
+	/* Select second dataflash chip (if present on selected board), send read status register command */
+	#if (DATAFLASH_TOTALCHIPS == 2)
+	Dataflash_SelectChip(DATAFLASH_CHIP2);
+	Dataflash_SendByte(DF_CMD_GETSTATUS);
+	
+	/* Check if sector protection is enabled */
+	if (Dataflash_ReceiveByte() & DF_STATUS_SECTORPROTECTION_ON)
+	{
+		Dataflash_ToggleSelectedChipCS();
+
+		/* Send the commands to disable sector protection */
+		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[0]);
+		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[1]);
+		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[2]);
+		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
+	}
+	#endif
+	
+	/* Deselect current dataflash chip */
+	Dataflash_DeselectChip();
+}
+
+/** Performs a simple test on the attached Dataflash IC(s) to ensure that they are working.
+ *
+ *  \return Boolean true if all media chips are working, false otherwise
+ */
+bool DataflashManager_CheckDataflashOperation(void)
+{
+	uint8_t ReturnByte;
+
+	/* Test first Dataflash IC is present and responding to commands */
+	Dataflash_SelectChip(DATAFLASH_CHIP1);
+	Dataflash_SendByte(DF_CMD_READMANUFACTURERDEVICEINFO);
+	ReturnByte = Dataflash_ReceiveByte();
+	Dataflash_DeselectChip();
+
+	/* If returned data is invalid, fail the command */
+	if (ReturnByte != DF_MANUFACTURER_ATMEL)
+	  return false;
+
+	#if (DATAFLASH_TOTALCHIPS == 2)
+	/* Test second Dataflash IC is present and responding to commands */
+	Dataflash_SelectChip(DATAFLASH_CHIP2);
+	Dataflash_SendByte(DF_CMD_READMANUFACTURERDEVICEINFO);
+	ReturnByte = Dataflash_ReceiveByte();
+	Dataflash_DeselectChip();
+
+	/* If returned data is invalid, fail the command */
+	if (ReturnByte != DF_MANUFACTURER_ATMEL)
+	  return false;
+	#endif
+	
+	return true;
+}
diff --git a/Projects/Webserver/Lib/DataflashManager.h b/Projects/Webserver/Lib/DataflashManager.h
index f475f449a..ebf0bd329 100644
--- a/Projects/Webserver/Lib/DataflashManager.h
+++ b/Projects/Webserver/Lib/DataflashManager.h
@@ -1,80 +1,80 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-/** \file

- *

- *  Header file for DataflashManager.c.

- */

- 

-#ifndef _DATAFLASH_MANAGER_H_

-#define _DATAFLASH_MANAGER_H_

-

-	/* Includes: */

-		#include <avr/io.h>

-		

-		#include "Descriptors.h"

-

-		#include <LUFA/Common/Common.h>

-		#include <LUFA/Drivers/USB/USB.h>

-		#include <LUFA/Drivers/USB/Class/MassStorage.h>

-		#include <LUFA/Drivers/Board/Dataflash.h>

-

-	/* Preprocessor Checks: */

-		#if (DATAFLASH_PAGE_SIZE % 16)

-			#error Dataflash page size must be a multiple of 16 bytes.

-		#endif

-

-	/* Defines: */

-		/** Total number of bytes of the storage medium, comprised of one or more dataflash ICs. */

-		#define VIRTUAL_MEMORY_BYTES                ((uint32_t)DATAFLASH_PAGES * DATAFLASH_PAGE_SIZE * DATAFLASH_TOTALCHIPS)

-

-		/** Block size of the device. This is kept at 512 to remain compatible with the OS despite the underlying

-		 *  storage media (Dataflash) using a different native block size. Do not change this value.

-		 */

-		#define VIRTUAL_MEMORY_BLOCK_SIZE           512

-		

-		/** Total number of blocks of the virtual memory for reporting to the host as the device's total capacity. Do not

-		 *  change this value; change VIRTUAL_MEMORY_BYTES instead to alter the media size.

-		 */

-		#define VIRTUAL_MEMORY_BLOCKS               (VIRTUAL_MEMORY_BYTES / VIRTUAL_MEMORY_BLOCK_SIZE)

-		

-	/* Function Prototypes: */

-		void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress,

-		                                  uint16_t TotalBlocks);

-		void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress,

-		                                 uint16_t TotalBlocks);

-		void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks,

-		                                      const uint8_t* BufferPtr) ATTR_NON_NULL_PTR_ARG(3);

-		void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks,

-		                                     uint8_t* BufferPtr) ATTR_NON_NULL_PTR_ARG(3);

-		void DataflashManager_ResetDataflashProtections(void);

-		bool DataflashManager_CheckDataflashOperation(void);

-		

-#endif

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  Header file for DataflashManager.c.
+ */
+ 
+#ifndef _DATAFLASH_MANAGER_H_
+#define _DATAFLASH_MANAGER_H_
+
+	/* Includes: */
+		#include <avr/io.h>
+		
+		#include "Descriptors.h"
+
+		#include <LUFA/Common/Common.h>
+		#include <LUFA/Drivers/USB/USB.h>
+		#include <LUFA/Drivers/USB/Class/MassStorage.h>
+		#include <LUFA/Drivers/Board/Dataflash.h>
+
+	/* Preprocessor Checks: */
+		#if (DATAFLASH_PAGE_SIZE % 16)
+			#error Dataflash page size must be a multiple of 16 bytes.
+		#endif
+
+	/* Defines: */
+		/** Total number of bytes of the storage medium, comprised of one or more dataflash ICs. */
+		#define VIRTUAL_MEMORY_BYTES                ((uint32_t)DATAFLASH_PAGES * DATAFLASH_PAGE_SIZE * DATAFLASH_TOTALCHIPS)
+
+		/** Block size of the device. This is kept at 512 to remain compatible with the OS despite the underlying
+		 *  storage media (Dataflash) using a different native block size. Do not change this value.
+		 */
+		#define VIRTUAL_MEMORY_BLOCK_SIZE           512
+		
+		/** Total number of blocks of the virtual memory for reporting to the host as the device's total capacity. Do not
+		 *  change this value; change VIRTUAL_MEMORY_BYTES instead to alter the media size.
+		 */
+		#define VIRTUAL_MEMORY_BLOCKS               (VIRTUAL_MEMORY_BYTES / VIRTUAL_MEMORY_BLOCK_SIZE)
+		
+	/* Function Prototypes: */
+		void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress,
+		                                  uint16_t TotalBlocks);
+		void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress,
+		                                 uint16_t TotalBlocks);
+		void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks,
+		                                      const uint8_t* BufferPtr) ATTR_NON_NULL_PTR_ARG(3);
+		void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks,
+		                                     uint8_t* BufferPtr) ATTR_NON_NULL_PTR_ARG(3);
+		void DataflashManager_ResetDataflashProtections(void);
+		bool DataflashManager_CheckDataflashOperation(void);
+		
+#endif
diff --git a/Projects/Webserver/Lib/FATFs/00readme.txt b/Projects/Webserver/Lib/FATFs/00readme.txt
index 295be3b9a..eb378c51e 100644
--- a/Projects/Webserver/Lib/FATFs/00readme.txt
+++ b/Projects/Webserver/Lib/FATFs/00readme.txt
@@ -1,110 +1,110 @@
-FatFs Module Source Files R0.07e                        (C)ChaN, 2010

-

-

-FILES

-

-  ffconf.h   Configuration file for FatFs module.

-  ff.h       Common include file for FatFs and application module.

-  ff.c       FatFs module.

-  diskio.h   Common include file for FatFs and disk I/O module.

-  diskio.c   Skeleton of low level disk I/O module.

-  integer.h  Alternative type definitions for integer variables.

-  option     Optional external functions.

-

-  Low level disk I/O module is not included in this archive because the FatFs

-  module is only a generic file system layer and not depend on any specific

-  storage device. You have to provide a low level disk I/O module that written

-  to control your storage device.

-

-

-

-AGREEMENTS

-

- FatFs module is an open source software to implement FAT file system to

- small embedded systems. This is a free software and is opened for education,

- research and commercial developments under license policy of following trems.

-

-  Copyright (C) 2010, ChaN, all right reserved.

-

- * The FatFs module is a free software and there is NO WARRANTY.

- * No restriction on use. You can use, modify and redistribute it for

-   personal, non-profit or commercial product UNDER YOUR RESPONSIBILITY.

- * Redistributions of source code must retain the above copyright notice.

-

-

-

-REVISION HISTORY

-

-  Feb 26, 2006  R0.00  Prototype

-

-  Apr 29, 2006  R0.01  First release.

-

-  Jun 01, 2006  R0.02  Added FAT12.

-                       Removed unbuffered mode.

-                       Fixed a problem on small (<32M) patition.

-

-  Jun 10, 2006  R0.02a Added a configuration option _FS_MINIMUM.

-

-  Sep 22, 2006  R0.03  Added f_rename.

-                       Changed option _FS_MINIMUM to _FS_MINIMIZE.

-

-  Dec 11, 2006  R0.03a Improved cluster scan algolithm to write files fast.

-                       Fixed f_mkdir creates incorrect directory on FAT32.

-

-  Feb 04, 2007  R0.04  Supported multiple drive system. (FatFs)

-                       Changed some APIs for multiple drive system.

-                       Added f_mkfs. (FatFs)

-                       Added _USE_FAT32 option. (Tiny-FatFs)

-

-  Apr 01, 2007  R0.04a Supported multiple partitions on a plysical drive. (FatFs)

-                       Fixed an endian sensitive code in f_mkfs. (FatFs)

-                       Added a capability of extending the file size to f_lseek.

-                       Added minimization level 3.

-                       Fixed a problem that can collapse a sector when recreate an

-                       existing file in any sub-directory at non FAT32 cfg. (Tiny-FatFs)

-

-  May 05, 2007  R0.04b Added _USE_NTFLAG option.

-                       Added FSInfo support.

-                       Fixed some problems corresponds to FAT32. (Tiny-FatFs)

-                       Fixed DBCS name can result FR_INVALID_NAME.

-                       Fixed short seek (0 < ofs <= csize) collapses the file object.

-

-  Aug 25, 2007  R0.05  Changed arguments of f_read, f_write.

-                       Changed arguments of f_mkfs. (FatFs)

-                       Fixed f_mkfs on FAT32 creates incorrect FSInfo. (FatFs)

-                       Fixed f_mkdir on FAT32 creates incorrect directory. (FatFs)

-

-  Feb 03, 2008  R0.05a Added f_truncate().

-                       Added f_utime().

-                       Fixed off by one error at FAT sub-type determination.

-                       Fixed btr in f_read() can be mistruncated.

-                       Fixed cached sector is not flushed when create and close without write.

-

-  Apr 01, 2008  R0.06  Added f_forward(). (Tiny-FatFs)

-                       Added string functions: fputc(), fputs(), fprintf() and fgets().

-                       Improved performance of f_lseek() on move to the same or following cluster.

-

-  Apr 01, 2010, R0.07  Merged Tiny-FatFs as a buffer configuration option.

-                       Added long file name support.

-                       Added multiple code page support.

-                       Added re-entrancy for multitask operation.

-                       Added auto cluster size selection to f_mkfs().

-                       Added rewind option to f_readdir().

-                       Changed result code of critical errors.

-                       Renamed string functions to avoid name collision.

-

-  Apr 14, 2010, R0.07a Separated out OS dependent code on reentrant cfg.

-                       Added multiple sector size support.

-

-  Jun 21, 2010, R0.07c Fixed f_unlink() may return FR_OK on error.

-                       Fixed wrong cache control in f_lseek().

-                       Added relative path feature.

-                       Added f_chdir().

-                       Added f_chdrive().

-                       Added proper case conversion for extended characters.

-

-  Nov 03,'2010 R0.07e  Separated out configuration options from ff.h to ffconf.h.

-                       Added a configuration option, _LFN_UNICODE.

-                       Fixed f_unlink() fails to remove a sub-dir on _FS_RPATH.

-                       Fixed name matching error on the 13 char boundary.

-                       Changed f_readdir() to return the SFN with always upper case on non-LFN cfg.

+FatFs Module Source Files R0.07e                        (C)ChaN, 2010
+
+
+FILES
+
+  ffconf.h   Configuration file for FatFs module.
+  ff.h       Common include file for FatFs and application module.
+  ff.c       FatFs module.
+  diskio.h   Common include file for FatFs and disk I/O module.
+  diskio.c   Skeleton of low level disk I/O module.
+  integer.h  Alternative type definitions for integer variables.
+  option     Optional external functions.
+
+  Low level disk I/O module is not included in this archive because the FatFs
+  module is only a generic file system layer and not depend on any specific
+  storage device. You have to provide a low level disk I/O module that written
+  to control your storage device.
+
+
+
+AGREEMENTS
+
+ FatFs module is an open source software to implement FAT file system to
+ small embedded systems. This is a free software and is opened for education,
+ research and commercial developments under license policy of following trems.
+
+  Copyright (C) 2010, ChaN, all right reserved.
+
+ * The FatFs module is a free software and there is NO WARRANTY.
+ * No restriction on use. You can use, modify and redistribute it for
+   personal, non-profit or commercial product UNDER YOUR RESPONSIBILITY.
+ * Redistributions of source code must retain the above copyright notice.
+
+
+
+REVISION HISTORY
+
+  Feb 26, 2006  R0.00  Prototype
+
+  Apr 29, 2006  R0.01  First release.
+
+  Jun 01, 2006  R0.02  Added FAT12.
+                       Removed unbuffered mode.
+                       Fixed a problem on small (<32M) patition.
+
+  Jun 10, 2006  R0.02a Added a configuration option _FS_MINIMUM.
+
+  Sep 22, 2006  R0.03  Added f_rename.
+                       Changed option _FS_MINIMUM to _FS_MINIMIZE.
+
+  Dec 11, 2006  R0.03a Improved cluster scan algolithm to write files fast.
+                       Fixed f_mkdir creates incorrect directory on FAT32.
+
+  Feb 04, 2007  R0.04  Supported multiple drive system. (FatFs)
+                       Changed some APIs for multiple drive system.
+                       Added f_mkfs. (FatFs)
+                       Added _USE_FAT32 option. (Tiny-FatFs)
+
+  Apr 01, 2007  R0.04a Supported multiple partitions on a plysical drive. (FatFs)
+                       Fixed an endian sensitive code in f_mkfs. (FatFs)
+                       Added a capability of extending the file size to f_lseek.
+                       Added minimization level 3.
+                       Fixed a problem that can collapse a sector when recreate an
+                       existing file in any sub-directory at non FAT32 cfg. (Tiny-FatFs)
+
+  May 05, 2007  R0.04b Added _USE_NTFLAG option.
+                       Added FSInfo support.
+                       Fixed some problems corresponds to FAT32. (Tiny-FatFs)
+                       Fixed DBCS name can result FR_INVALID_NAME.
+                       Fixed short seek (0 < ofs <= csize) collapses the file object.
+
+  Aug 25, 2007  R0.05  Changed arguments of f_read, f_write.
+                       Changed arguments of f_mkfs. (FatFs)
+                       Fixed f_mkfs on FAT32 creates incorrect FSInfo. (FatFs)
+                       Fixed f_mkdir on FAT32 creates incorrect directory. (FatFs)
+
+  Feb 03, 2008  R0.05a Added f_truncate().
+                       Added f_utime().
+                       Fixed off by one error at FAT sub-type determination.
+                       Fixed btr in f_read() can be mistruncated.
+                       Fixed cached sector is not flushed when create and close without write.
+
+  Apr 01, 2008  R0.06  Added f_forward(). (Tiny-FatFs)
+                       Added string functions: fputc(), fputs(), fprintf() and fgets().
+                       Improved performance of f_lseek() on move to the same or following cluster.
+
+  Apr 01, 2010, R0.07  Merged Tiny-FatFs as a buffer configuration option.
+                       Added long file name support.
+                       Added multiple code page support.
+                       Added re-entrancy for multitask operation.
+                       Added auto cluster size selection to f_mkfs().
+                       Added rewind option to f_readdir().
+                       Changed result code of critical errors.
+                       Renamed string functions to avoid name collision.
+
+  Apr 14, 2010, R0.07a Separated out OS dependent code on reentrant cfg.
+                       Added multiple sector size support.
+
+  Jun 21, 2010, R0.07c Fixed f_unlink() may return FR_OK on error.
+                       Fixed wrong cache control in f_lseek().
+                       Added relative path feature.
+                       Added f_chdir().
+                       Added f_chdrive().
+                       Added proper case conversion for extended characters.
+
+  Nov 03,'2010 R0.07e  Separated out configuration options from ff.h to ffconf.h.
+                       Added a configuration option, _LFN_UNICODE.
+                       Fixed f_unlink() fails to remove a sub-dir on _FS_RPATH.
+                       Fixed name matching error on the 13 char boundary.
+                       Changed f_readdir() to return the SFN with always upper case on non-LFN cfg.
diff --git a/Projects/Webserver/Lib/FATFs/diskio.c b/Projects/Webserver/Lib/FATFs/diskio.c
index 028c631ba..d81885c29 100644
--- a/Projects/Webserver/Lib/FATFs/diskio.c
+++ b/Projects/Webserver/Lib/FATFs/diskio.c
@@ -1,64 +1,64 @@
-/*-----------------------------------------------------------------------*/

-/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2007        */

-/*-----------------------------------------------------------------------*/

-/* This is a stub disk I/O module that acts as front end of the existing */

-/* disk I/O modules and attach it to FatFs module with common interface. */

-/*-----------------------------------------------------------------------*/

-

-#include "diskio.h"

-

-/*-----------------------------------------------------------------------*/

-/* Inidialize a Drive                                                    */

-

-DSTATUS disk_initialize (

-	BYTE drv				/* Physical drive nmuber (0..) */

-)

-{

-	return FR_OK;

-}

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Return Disk Status                                                    */

-

-DSTATUS disk_status (

-	BYTE drv		/* Physical drive nmuber (0..) */

-)

-{

-	return FR_OK;

-}

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Read Sector(s)                                                        */

-

-DRESULT disk_read (

-	BYTE drv,		/* Physical drive nmuber (0..) */

-	BYTE *buff,		/* Data buffer to store read data */

-	DWORD sector,	/* Sector address (LBA) */

-	BYTE count		/* Number of sectors to read (1..255) */

-)

-{

-	DataflashManager_ReadBlocks_RAM(sector, count, buff);

-	return RES_OK;

-}

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Write Sector(s)                                                       */

-

-#if _READONLY == 0

-DRESULT disk_write (

-	BYTE drv,			/* Physical drive nmuber (0..) */

-	const BYTE *buff,	/* Data to be written */

-	DWORD sector,		/* Sector address (LBA) */

-	BYTE count			/* Number of sectors to write (1..255) */

-)

-{

-	DataflashManager_WriteBlocks_RAM(sector, count, buff);

-	return RES_OK;

-}

-#endif /* _READONLY */

+/*-----------------------------------------------------------------------*/
+/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2007        */
+/*-----------------------------------------------------------------------*/
+/* This is a stub disk I/O module that acts as front end of the existing */
+/* disk I/O modules and attach it to FatFs module with common interface. */
+/*-----------------------------------------------------------------------*/
+
+#include "diskio.h"
+
+/*-----------------------------------------------------------------------*/
+/* Inidialize a Drive                                                    */
+
+DSTATUS disk_initialize (
+	BYTE drv				/* Physical drive nmuber (0..) */
+)
+{
+	return FR_OK;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Return Disk Status                                                    */
+
+DSTATUS disk_status (
+	BYTE drv		/* Physical drive nmuber (0..) */
+)
+{
+	return FR_OK;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Sector(s)                                                        */
+
+DRESULT disk_read (
+	BYTE drv,		/* Physical drive nmuber (0..) */
+	BYTE *buff,		/* Data buffer to store read data */
+	DWORD sector,	/* Sector address (LBA) */
+	BYTE count		/* Number of sectors to read (1..255) */
+)
+{
+	DataflashManager_ReadBlocks_RAM(sector, count, buff);
+	return RES_OK;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Write Sector(s)                                                       */
+
+#if _READONLY == 0
+DRESULT disk_write (
+	BYTE drv,			/* Physical drive nmuber (0..) */
+	const BYTE *buff,	/* Data to be written */
+	DWORD sector,		/* Sector address (LBA) */
+	BYTE count			/* Number of sectors to write (1..255) */
+)
+{
+	DataflashManager_WriteBlocks_RAM(sector, count, buff);
+	return RES_OK;
+}
+#endif /* _READONLY */
diff --git a/Projects/Webserver/Lib/FATFs/diskio.h b/Projects/Webserver/Lib/FATFs/diskio.h
index 2f444f7b6..bd9d223c0 100644
--- a/Projects/Webserver/Lib/FATFs/diskio.h
+++ b/Projects/Webserver/Lib/FATFs/diskio.h
@@ -1,72 +1,72 @@
-/*-----------------------------------------------------------------------

-/  Low level disk interface modlue include file  R0.07   (C)ChaN, 2010

-/-----------------------------------------------------------------------*/

-

-#ifndef _DISKIO

-

-#define _READONLY	0	/* 1: Read-only mode */

-#define _USE_IOCTL	0

-

-#include "integer.h"

-#include "ff.h"

-

-#include "../DataflashManager.h"

-

-

-/* Status of Disk Functions */

-typedef BYTE	DSTATUS;

-

-/* Results of Disk Functions */

-typedef enum {

-	RES_OK = 0,		/* 0: Successful */

-	RES_ERROR,		/* 1: R/W Error */

-	RES_WRPRT,		/* 2: Write Protected */

-	RES_NOTRDY,		/* 3: Not Ready */

-	RES_PARERR		/* 4: Invalid Parameter */

-} DRESULT;

-

-

-/*---------------------------------------*/

-/* Prototypes for disk control functions */

-

-BOOL assign_drives (int argc, char *argv[]);

-DSTATUS disk_initialize (BYTE);

-DSTATUS disk_status (BYTE);

-DRESULT disk_read (BYTE, BYTE*, DWORD, BYTE);

-#if	_READONLY == 0

-DRESULT disk_write (BYTE, const BYTE*, DWORD, BYTE);

-#endif

-DRESULT disk_ioctl (BYTE, BYTE, void*);

-

-

-/* Disk Status Bits (DSTATUS) */

-

-#define STA_NOINIT		0x01	/* Drive not initialized */

-#define STA_NODISK		0x02	/* No medium in the drive */

-#define STA_PROTECT		0x04	/* Write protected */

-

-

-/* Command code for disk_ioctrl() */

-

-/* Generic command */

-#define CTRL_SYNC			0	/* Mandatory for write functions */

-#define GET_SECTOR_COUNT	1	/* Mandatory for only f_mkfs() */

-#define GET_SECTOR_SIZE		2	/* Mandatory for multiple sector size cfg */

-#define GET_BLOCK_SIZE		3	/* Mandatory for only f_mkfs() */

-#define CTRL_POWER			4

-#define CTRL_LOCK			5

-#define CTRL_EJECT			6

-/* MMC/SDC command */

-#define MMC_GET_TYPE		10

-#define MMC_GET_CSD			11

-#define MMC_GET_CID			12

-#define MMC_GET_OCR			13

-#define MMC_GET_SDSTAT		14

-/* ATA/CF command */

-#define ATA_GET_REV			20

-#define ATA_GET_MODEL		21

-#define ATA_GET_SN			22

-

-

-#define _DISKIO

-#endif

+/*-----------------------------------------------------------------------
+/  Low level disk interface modlue include file  R0.07   (C)ChaN, 2010
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO
+
+#define _READONLY	0	/* 1: Read-only mode */
+#define _USE_IOCTL	0
+
+#include "integer.h"
+#include "ff.h"
+
+#include "../DataflashManager.h"
+
+
+/* Status of Disk Functions */
+typedef BYTE	DSTATUS;
+
+/* Results of Disk Functions */
+typedef enum {
+	RES_OK = 0,		/* 0: Successful */
+	RES_ERROR,		/* 1: R/W Error */
+	RES_WRPRT,		/* 2: Write Protected */
+	RES_NOTRDY,		/* 3: Not Ready */
+	RES_PARERR		/* 4: Invalid Parameter */
+} DRESULT;
+
+
+/*---------------------------------------*/
+/* Prototypes for disk control functions */
+
+BOOL assign_drives (int argc, char *argv[]);
+DSTATUS disk_initialize (BYTE);
+DSTATUS disk_status (BYTE);
+DRESULT disk_read (BYTE, BYTE*, DWORD, BYTE);
+#if	_READONLY == 0
+DRESULT disk_write (BYTE, const BYTE*, DWORD, BYTE);
+#endif
+DRESULT disk_ioctl (BYTE, BYTE, void*);
+
+
+/* Disk Status Bits (DSTATUS) */
+
+#define STA_NOINIT		0x01	/* Drive not initialized */
+#define STA_NODISK		0x02	/* No medium in the drive */
+#define STA_PROTECT		0x04	/* Write protected */
+
+
+/* Command code for disk_ioctrl() */
+
+/* Generic command */
+#define CTRL_SYNC			0	/* Mandatory for write functions */
+#define GET_SECTOR_COUNT	1	/* Mandatory for only f_mkfs() */
+#define GET_SECTOR_SIZE		2	/* Mandatory for multiple sector size cfg */
+#define GET_BLOCK_SIZE		3	/* Mandatory for only f_mkfs() */
+#define CTRL_POWER			4
+#define CTRL_LOCK			5
+#define CTRL_EJECT			6
+/* MMC/SDC command */
+#define MMC_GET_TYPE		10
+#define MMC_GET_CSD			11
+#define MMC_GET_CID			12
+#define MMC_GET_OCR			13
+#define MMC_GET_SDSTAT		14
+/* ATA/CF command */
+#define ATA_GET_REV			20
+#define ATA_GET_MODEL		21
+#define ATA_GET_SN			22
+
+
+#define _DISKIO
+#endif
diff --git a/Projects/Webserver/Lib/FATFs/ff.c b/Projects/Webserver/Lib/FATFs/ff.c
index 6382fea1f..b30139055 100644
--- a/Projects/Webserver/Lib/FATFs/ff.c
+++ b/Projects/Webserver/Lib/FATFs/ff.c
@@ -1,3153 +1,3153 @@
-/*----------------------------------------------------------------------------/

-/  FatFs - FAT file system module  R0.07e                    (C)ChaN, 2010

-/-----------------------------------------------------------------------------/

-/ FatFs module is a generic FAT file system module for small embedded systems.

-/ This is a free software that opened for education, research and commercial

-/ developments under license policy of following trems.

-/

-/  Copyright (C) 2010, ChaN, all right reserved.

-/

-/ * The FatFs module is a free software and there is NO WARRANTY.

-/ * No restriction on use. You can use, modify and redistribute it for

-/   personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY.

-/ * Redistributions of source code must retain the above copyright notice.

-/

-/-----------------------------------------------------------------------------/

-/ Feb 26,'06 R0.00  Prototype.

-/

-/ Apr 29,'06 R0.01  First stable version.

-/

-/ Jun 01,'06 R0.02  Added FAT12 support.

-/                   Removed unbuffered mode.

-/                   Fixed a problem on small (<32M) patition.

-/ Jun 10,'06 R0.02a Added a configuration option (_FS_MINIMUM).

-/

-/ Sep 22,'06 R0.03  Added f_rename().

-/                   Changed option _FS_MINIMUM to _FS_MINIMIZE.

-/ Dec 11,'06 R0.03a Improved cluster scan algolithm to write files fast.

-/                   Fixed f_mkdir() creates incorrect directory on FAT32.

-/

-/ Feb 04,'07 R0.04  Supported multiple drive system.

-/                   Changed some interfaces for multiple drive system.

-/                   Changed f_mountdrv() to f_mount().

-/                   Added f_mkfs().

-/ Apr 01,'07 R0.04a Supported multiple partitions on a plysical drive.

-/                   Added a capability of extending file size to f_lseek().

-/                   Added minimization level 3.

-/                   Fixed an endian sensitive code in f_mkfs().

-/ May 05,'07 R0.04b Added a configuration option _USE_NTFLAG.

-/                   Added FSInfo support.

-/                   Fixed DBCS name can result FR_INVALID_NAME.

-/                   Fixed short seek (<= csize) collapses the file object.

-/

-/ Aug 25,'07 R0.05  Changed arguments of f_read(), f_write() and f_mkfs().

-/                   Fixed f_mkfs() on FAT32 creates incorrect FSInfo.

-/                   Fixed f_mkdir() on FAT32 creates incorrect directory.

-/ Feb 03,'08 R0.05a Added f_truncate() and f_utime().

-/                   Fixed off by one error at FAT sub-type determination.

-/                   Fixed btr in f_read() can be mistruncated.

-/                   Fixed cached sector is not flushed when create and close

-/                   without write.

-/

-/ Apr 01,'08 R0.06  Added fputc(), fputs(), fprintf() and fgets().

-/                   Improved performance of f_lseek() on moving to the same

-/                   or following cluster.

-/

-/ Apr 01,'09 R0.07  Merged Tiny-FatFs as a buffer configuration option.

-/                   Added long file name support.

-/                   Added multiple code page support.

-/                   Added re-entrancy for multitask operation.

-/                   Added auto cluster size selection to f_mkfs().

-/                   Added rewind option to f_readdir().

-/                   Changed result code of critical errors.

-/                   Renamed string functions to avoid name collision.

-/ Apr 14,'09 R0.07a Separated out OS dependent code on reentrant cfg.

-/                   Added multiple sector size support.

-/ Jun 21,'09 R0.07c Fixed f_unlink() can return FR_OK on error.

-/                   Fixed wrong cache control in f_lseek().

-/                   Added relative path feature.

-/                   Added f_chdir() and f_chdrive().

-/                   Added proper case conversion to extended char.

-/ Nov 03,'09 R0.07e Separated out configuration options from ff.h to ffconf.h.

-/                   Fixed f_unlink() fails to remove a sub-dir on _FS_RPATH.

-/                   Fixed name matching error on the 13 char boundary.

-/                   Added a configuration option, _LFN_UNICODE.

-/                   Changed f_readdir() to return the SFN with always upper

-/                   case on non-LFN cfg.

-/---------------------------------------------------------------------------*/

-

-#include "ff.h"			/* FatFs configurations and declarations */

-#include "diskio.h"		/* Declarations of low level disk I/O functions */

-

-/*--------------------------------------------------------------------------

-

-   Module Private Definitions

-

----------------------------------------------------------------------------*/

-

-#if _FATFS != 0x007E

-#error Wrong include file (ff.h).

-#endif

-

-#if _FS_REENTRANT

-#if _USE_LFN == 1

-#error Static LFN work area must not be used in re-entrant configuration.

-#endif

-#define	ENTER_FF(fs)		{ if (!lock_fs(fs)) return FR_TIMEOUT; }

-#define	LEAVE_FF(fs, res)	{ unlock_fs(fs, res); return res; }

-

-#else

-#define	ENTER_FF(fs)

-#define LEAVE_FF(fs, res)	return res

-

-#endif

-

-#define	ABORT(fs, res)		{ fp->flag |= FA__ERROR; LEAVE_FF(fs, res); }

-

-#ifndef NULL

-#define	NULL	0

-#endif

-

-/* Name status flags */

-#define NS			11		/* Offset of name status byte */

-#define NS_LOSS		0x01	/* Out of 8.3 format */

-#define NS_LFN		0x02	/* Force to create LFN entry */

-#define NS_LAST		0x04	/* Last segment */

-#define NS_BODY		0x08	/* Lower case flag (body) */

-#define NS_EXT		0x10	/* Lower case flag (ext) */

-#define NS_DOT		0x20	/* Dot entry */

-

-

-

-

-/*--------------------------------------------------------------------------

-

-   Private Work Area

-

----------------------------------------------------------------------------*/

-

-#if _DRIVES < 1 || _DRIVES > 9

-#error Number of drives must be 1-9.

-#endif

-static

-FATFS *FatFs[_DRIVES];	/* Pointer to the file system objects (logical drives) */

-

-static

-WORD Fsid;				/* File system mount ID */

-

-#if _FS_RPATH

-static

-BYTE Drive;				/* Current drive */

-#endif

-

-

-#if _USE_LFN == 1	/* LFN with static LFN working buffer */

-static

-WCHAR LfnBuf[_MAX_LFN + 1];

-#define	NAMEBUF(sp,lp)	BYTE sp[12]; WCHAR *lp = LfnBuf

-#define INITBUF(dj,sp,lp)	dj.fn = sp; dj.lfn = lp

-

-#elif _USE_LFN > 1	/* LFN with dynamic LFN working buffer */

-#define	NAMEBUF(sp,lp)	BYTE sp[12]; WCHAR lbuf[_MAX_LFN + 1], *lp = lbuf

-#define INITBUF(dj,sp,lp)	dj.fn = sp; dj.lfn = lp

-

-#else				/* No LFN */

-#define	NAMEBUF(sp,lp)	BYTE sp[12]

-#define INITBUF(dj,sp,lp)	dj.fn = sp

-

-#endif

-

-

-

-

-/*--------------------------------------------------------------------------

-

-   Module Private Functions

-

----------------------------------------------------------------------------*/

-

-

-/*-----------------------------------------------------------------------*/

-/* String functions                                                      */

-/*-----------------------------------------------------------------------*/

-

-/* Copy memory to memory */

-static

-void mem_cpy (void* dst, const void* src, int cnt) {

-	char *d = (char*)dst;

-	const char *s = (const char *)src;

-	while (cnt--) *d++ = *s++;

-}

-

-/* Fill memory */

-static

-void mem_set (void* dst, int val, int cnt) {

-	char *d = (char*)dst;

-	while (cnt--) *d++ = (char)val;

-}

-

-/* Compare memory to memory */

-static

-int mem_cmp (const void* dst, const void* src, int cnt) {

-	const char *d = (const char *)dst, *s = (const char *)src;

-	int r = 0;

-	while (cnt-- && (r = *d++ - *s++) == 0) ;

-	return r;

-}

-

-/* Check if chr is contained in the string */

-static

-int chk_chr (const char* str, int chr) {

-	while (*str && *str != chr) str++;

-	return *str;

-}

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Request/Release grant to access the volume                            */

-/*-----------------------------------------------------------------------*/

-#if _FS_REENTRANT

-

-static

-BOOL lock_fs (

-	FATFS *fs		/* File system object */

-)

-{

-	return ff_req_grant(fs->sobj);

-}

-

-

-static

-void unlock_fs (

-	FATFS *fs,		/* File system object */

-	FRESULT res		/* Result code to be returned */

-)

-{

-	if (res != FR_NOT_ENABLED &&

-		res != FR_INVALID_DRIVE &&

-		res != FR_INVALID_OBJECT &&

-		res != FR_TIMEOUT) {

-		ff_rel_grant(fs->sobj);

-	}

-}

-#endif

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Change window offset                                                  */

-/*-----------------------------------------------------------------------*/

-

-static

-FRESULT move_window (

-	FATFS *fs,		/* File system object */

-	DWORD sector	/* Sector number to make apperance in the fs->win[] */

-)					/* Move to zero only writes back dirty window */

-{

-	DWORD wsect;

-

-

-	wsect = fs->winsect;

-	if (wsect != sector) {	/* Changed current window */

-#if !_FS_READONLY

-		if (fs->wflag) {	/* Write back dirty window if needed */

-			if (disk_write(fs->drive, fs->win, wsect, 1) != RES_OK)

-				return FR_DISK_ERR;

-			fs->wflag = 0;

-			if (wsect < (fs->fatbase + fs->sects_fat)) {	/* In FAT area */

-				BYTE nf;

-				for (nf = fs->n_fats; nf > 1; nf--) {	/* Refrect the change to all FAT copies */

-					wsect += fs->sects_fat;

-					disk_write(fs->drive, fs->win, wsect, 1);

-				}

-			}

-		}

-#endif

-		if (sector) {

-			if (disk_read(fs->drive, fs->win, sector, 1) != RES_OK)

-				return FR_DISK_ERR;

-			fs->winsect = sector;

-		}

-	}

-

-	return FR_OK;

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Clean-up cached data                                                  */

-/*-----------------------------------------------------------------------*/

-#if !_FS_READONLY

-static

-FRESULT sync (	/* FR_OK: successful, FR_DISK_ERR: failed */

-	FATFS *fs	/* File system object */

-)

-{

-	FRESULT res;

-

-

-	res = move_window(fs, 0);

-	if (res == FR_OK) {

-		/* Update FSInfo sector if needed */

-		if (fs->fs_type == FS_FAT32 && fs->fsi_flag) {

-			fs->winsect = 0;

-			mem_set(fs->win, 0, 512);

-			ST_WORD(fs->win+BS_55AA, 0xAA55);

-			ST_DWORD(fs->win+FSI_LeadSig, 0x41615252);

-			ST_DWORD(fs->win+FSI_StrucSig, 0x61417272);

-			ST_DWORD(fs->win+FSI_Free_Count, fs->free_clust);

-			ST_DWORD(fs->win+FSI_Nxt_Free, fs->last_clust);

-			disk_write(fs->drive, fs->win, fs->fsi_sector, 1);

-			fs->fsi_flag = 0;

-		}

-		/* Make sure that no pending write process in the physical drive */

-		if (disk_ioctl(fs->drive, CTRL_SYNC, (void*)NULL) != RES_OK)

-			res = FR_DISK_ERR;

-	}

-

-	return res;

-}

-#endif

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* FAT access - Read value of a FAT entry                                */

-/*-----------------------------------------------------------------------*/

-

-

-DWORD get_fat (	/* 0xFFFFFFFF:Disk error, 1:Interal error, Else:Cluster status */

-	FATFS *fs,	/* File system object */

-	DWORD clst	/* Cluster# to get the link information */

-)

-{

-	UINT wc, bc;

-	DWORD fsect;

-

-

-	if (clst < 2 || clst >= fs->max_clust)	/* Range check */

-		return 1;

-

-	fsect = fs->fatbase;

-	switch (fs->fs_type) {

-	case FS_FAT12 :

-		bc = clst; bc += bc / 2;

-		if (move_window(fs, fsect + (bc / SS(fs)))) break;

-		wc = fs->win[bc & (SS(fs) - 1)]; bc++;

-		if (move_window(fs, fsect + (bc / SS(fs)))) break;

-		wc |= (WORD)fs->win[bc & (SS(fs) - 1)] << 8;

-		return (clst & 1) ? (wc >> 4) : (wc & 0xFFF);

-

-	case FS_FAT16 :

-		if (move_window(fs, fsect + (clst / (SS(fs) / 2)))) break;

-		return LD_WORD(&fs->win[((WORD)clst * 2) & (SS(fs) - 1)]);

-

-	case FS_FAT32 :

-		if (move_window(fs, fsect + (clst / (SS(fs) / 4)))) break;

-		return LD_DWORD(&fs->win[((WORD)clst * 4) & (SS(fs) - 1)]) & 0x0FFFFFFF;

-	}

-

-	return 0xFFFFFFFF;	/* An error occured at the disk I/O layer */

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* FAT access - Change value of a FAT entry                              */

-/*-----------------------------------------------------------------------*/

-#if !_FS_READONLY

-

-FRESULT put_fat (

-	FATFS *fs,	/* File system object */

-	DWORD clst,	/* Cluster# to be changed in range of 2 to fs->max_clust - 1 */

-	DWORD val	/* New value to mark the cluster */

-)

-{

-	UINT bc;

-	BYTE *p;

-	DWORD fsect;

-	FRESULT res;

-

-

-	if (clst < 2 || clst >= fs->max_clust) {	/* Range check */

-		res = FR_INT_ERR;

-

-	} else {

-		fsect = fs->fatbase;

-		switch (fs->fs_type) {

-		case FS_FAT12 :

-			bc = clst; bc += bc / 2;

-			res = move_window(fs, fsect + (bc / SS(fs)));

-			if (res != FR_OK) break;

-			p = &fs->win[bc & (SS(fs) - 1)];

-			*p = (clst & 1) ? ((*p & 0x0F) | ((BYTE)val << 4)) : (BYTE)val;

-			bc++;

-			fs->wflag = 1;

-			res = move_window(fs, fsect + (bc / SS(fs)));

-			if (res != FR_OK) break;

-			p = &fs->win[bc & (SS(fs) - 1)];

-			*p = (clst & 1) ? (BYTE)(val >> 4) : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F));

-			break;

-

-		case FS_FAT16 :

-			res = move_window(fs, fsect + (clst / (SS(fs) / 2)));

-			if (res != FR_OK) break;

-			ST_WORD(&fs->win[((WORD)clst * 2) & (SS(fs) - 1)], (WORD)val);

-			break;

-

-		case FS_FAT32 :

-			res = move_window(fs, fsect + (clst / (SS(fs) / 4)));

-			if (res != FR_OK) break;

-			ST_DWORD(&fs->win[((WORD)clst * 4) & (SS(fs) - 1)], val);

-			break;

-

-		default :

-			res = FR_INT_ERR;

-		}

-		fs->wflag = 1;

-	}

-

-	return res;

-}

-#endif /* !_FS_READONLY */

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* FAT handling - Remove a cluster chain                                 */

-/*-----------------------------------------------------------------------*/

-#if !_FS_READONLY

-static

-FRESULT remove_chain (

-	FATFS *fs,			/* File system object */

-	DWORD clst			/* Cluster# to remove a chain from */

-)

-{

-	FRESULT res;

-	DWORD nxt;

-

-

-	if (clst < 2 || clst >= fs->max_clust) {	/* Check the range of cluster# */

-		res = FR_INT_ERR;

-

-	} else {

-		res = FR_OK;

-		while (clst < fs->max_clust) {			/* Not a last link? */

-			nxt = get_fat(fs, clst);			/* Get cluster status */

-			if (nxt == 0) break;				/* Empty cluster? */

-			if (nxt == 1) { res = FR_INT_ERR; break; }	/* Internal error? */

-			if (nxt == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }	/* Disk error? */

-			res = put_fat(fs, clst, 0);			/* Mark the cluster "empty" */

-			if (res != FR_OK) break;

-			if (fs->free_clust != 0xFFFFFFFF) {	/* Update FSInfo */

-				fs->free_clust++;

-				fs->fsi_flag = 1;

-			}

-			clst = nxt;	/* Next cluster */

-		}

-	}

-

-	return res;

-}

-#endif

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* FAT handling - Stretch or Create a cluster chain                      */

-/*-----------------------------------------------------------------------*/

-#if !_FS_READONLY

-static

-DWORD create_chain (	/* 0:No free cluster, 1:Internal error, 0xFFFFFFFF:Disk error, >=2:New cluster# */

-	FATFS *fs,			/* File system object */

-	DWORD clst			/* Cluster# to stretch. 0 means create a new chain. */

-)

-{

-	DWORD cs, ncl, scl, mcl;

-

-

-	mcl = fs->max_clust;

-	if (clst == 0) {		/* Create new chain */

-		scl = fs->last_clust;			/* Get suggested start point */

-		if (scl == 0 || scl >= mcl) scl = 1;

-	}

-	else {					/* Stretch existing chain */

-		cs = get_fat(fs, clst);			/* Check the cluster status */

-		if (cs < 2) return 1;			/* It is an invalid cluster */

-		if (cs < mcl) return cs;		/* It is already followed by next cluster */

-		scl = clst;

-	}

-

-	ncl = scl;				/* Start cluster */

-	for (;;) {

-		ncl++;							/* Next cluster */

-		if (ncl >= mcl) {				/* Wrap around */

-			ncl = 2;

-			if (ncl > scl) return 0;	/* No free custer */

-		}

-		cs = get_fat(fs, ncl);			/* Get the cluster status */

-		if (cs == 0) break;				/* Found a free cluster */

-		if (cs == 0xFFFFFFFF || cs == 1)/* An error occured */

-			return cs;

-		if (ncl == scl) return 0;		/* No free custer */

-	}

-

-	if (put_fat(fs, ncl, 0x0FFFFFFF))	/* Mark the new cluster "in use" */

-		return 0xFFFFFFFF;

-	if (clst != 0) {					/* Link it to the previous one if needed */

-		if (put_fat(fs, clst, ncl))

-			return 0xFFFFFFFF;

-	}

-

-	fs->last_clust = ncl;				/* Update FSINFO */

-	if (fs->free_clust != 0xFFFFFFFF) {

-		fs->free_clust--;

-		fs->fsi_flag = 1;

-	}

-

-	return ncl;		/* Return new cluster number */

-}

-#endif /* !_FS_READONLY */

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Get sector# from cluster#                                             */

-/*-----------------------------------------------------------------------*/

-

-

-DWORD clust2sect (	/* !=0: Sector number, 0: Failed - invalid cluster# */

-	FATFS *fs,		/* File system object */

-	DWORD clst		/* Cluster# to be converted */

-)

-{

-	clst -= 2;

-	if (clst >= (fs->max_clust - 2)) return 0;		/* Invalid cluster# */

-	return clst * fs->csize + fs->database;

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Directory handling - Seek directory index                             */

-/*-----------------------------------------------------------------------*/

-

-static

-FRESULT dir_seek (

-	DIR *dj,		/* Pointer to directory object */

-	WORD idx		/* Directory index number */

-)

-{

-	DWORD clst;

-	WORD ic;

-

-

-	dj->index = idx;

-	clst = dj->sclust;

-	if (clst == 1 || clst >= dj->fs->max_clust)	/* Check start cluster range */

-		return FR_INT_ERR;

-	if (!clst && dj->fs->fs_type == FS_FAT32)	/* Replace cluster# 0 with root cluster# if in FAT32 */

-		clst = dj->fs->dirbase;

-

-	if (clst == 0) {	/* Static table */

-		dj->clust = clst;

-		if (idx >= dj->fs->n_rootdir)		/* Index is out of range */

-			return FR_INT_ERR;

-		dj->sect = dj->fs->dirbase + idx / (SS(dj->fs) / 32);	/* Sector# */

-	}

-	else {				/* Dynamic table */

-		ic = SS(dj->fs) / 32 * dj->fs->csize;	/* Entries per cluster */

-		while (idx >= ic) {	/* Follow cluster chain */

-			clst = get_fat(dj->fs, clst);				/* Get next cluster */

-			if (clst == 0xFFFFFFFF) return FR_DISK_ERR;	/* Disk error */

-			if (clst < 2 || clst >= dj->fs->max_clust)	/* Reached to end of table or int error */

-				return FR_INT_ERR;

-			idx -= ic;

-		}

-		dj->clust = clst;

-		dj->sect = clust2sect(dj->fs, clst) + idx / (SS(dj->fs) / 32);	/* Sector# */

-	}

-

-	dj->dir = dj->fs->win + (idx % (SS(dj->fs) / 32)) * 32;	/* Ptr to the entry in the sector */

-

-	return FR_OK;	/* Seek succeeded */

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Directory handling - Move directory index next                        */

-/*-----------------------------------------------------------------------*/

-

-static

-FRESULT dir_next (	/* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT and could not streach */

-	DIR *dj,		/* Pointer to directory object */

-	BOOL streach	/* FALSE: Do not streach table, TRUE: Streach table if needed */

-)

-{

-	DWORD clst;

-	WORD i;

-

-

-	i = dj->index + 1;

-	if (!i || !dj->sect)	/* Report EOT when index has reached 65535 */

-		return FR_NO_FILE;

-

-	if (!(i % (SS(dj->fs) / 32))) {	/* Sector changed? */

-		dj->sect++;					/* Next sector */

-

-		if (dj->clust == 0) {	/* Static table */

-			if (i >= dj->fs->n_rootdir)	/* Report EOT when end of table */

-				return FR_NO_FILE;

-		}

-		else {					/* Dynamic table */

-			if (((i / (SS(dj->fs) / 32)) & (dj->fs->csize - 1)) == 0) {	/* Cluster changed? */

-				clst = get_fat(dj->fs, dj->clust);				/* Get next cluster */

-				if (clst <= 1) return FR_INT_ERR;

-				if (clst == 0xFFFFFFFF) return FR_DISK_ERR;

-				if (clst >= dj->fs->max_clust) {				/* When it reached end of dynamic table */

-#if !_FS_READONLY

-					BYTE c;

-					if (!streach) return FR_NO_FILE;			/* When do not streach, report EOT */

-					clst = create_chain(dj->fs, dj->clust);		/* Streach cluster chain */

-					if (clst == 0) return FR_DENIED;			/* No free cluster */

-					if (clst == 1) return FR_INT_ERR;

-					if (clst == 0xFFFFFFFF) return FR_DISK_ERR;

-					/* Clean-up streached table */

-					if (move_window(dj->fs, 0)) return FR_DISK_ERR;	/* Flush active window */

-					mem_set(dj->fs->win, 0, SS(dj->fs));			/* Clear window buffer */

-					dj->fs->winsect = clust2sect(dj->fs, clst);	/* Cluster start sector */

-					for (c = 0; c < dj->fs->csize; c++) {		/* Fill the new cluster with 0 */

-						dj->fs->wflag = 1;

-						if (move_window(dj->fs, 0)) return FR_DISK_ERR;

-						dj->fs->winsect++;

-					}

-					dj->fs->winsect -= c;						/* Rewind window address */

-#else

-					return FR_NO_FILE;			/* Report EOT */

-#endif

-				}

-				dj->clust = clst;				/* Initialize data for new cluster */

-				dj->sect = clust2sect(dj->fs, clst);

-			}

-		}

-	}

-

-	dj->index = i;

-	dj->dir = dj->fs->win + (i % (SS(dj->fs) / 32)) * 32;

-

-	return FR_OK;

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* LFN handling - Test/Pick/Fit an LFN segment from/to directory entry   */

-/*-----------------------------------------------------------------------*/

-#if _USE_LFN

-static

-const BYTE LfnOfs[] = {1,3,5,7,9,14,16,18,20,22,24,28,30};	/* Offset of LFN chars in the directory entry */

-

-

-static

-BOOL cmp_lfn (			/* TRUE:Matched, FALSE:Not matched */

-	WCHAR *lfnbuf,		/* Pointer to the LFN to be compared */

-	BYTE *dir			/* Pointer to the directory entry containing a part of LFN */

-)

-{

-	int i, s;

-	WCHAR wc, uc;

-

-

-	i = ((dir[LDIR_Ord] & 0xBF) - 1) * 13;	/* Get offset in the LFN buffer */

-	s = 0; wc = 1;

-	do {

-		uc = LD_WORD(dir+LfnOfs[s]);	/* Pick an LFN character from the entry */

-		if (wc) {	/* Last char has not been processed */

-			wc = ff_wtoupper(uc);		/* Convert it to upper case */

-			if (i >= _MAX_LFN || wc != ff_wtoupper(lfnbuf[i++]))	/* Compare it */

-				return FALSE;			/* Not matched */

-		} else {

-			if (uc != 0xFFFF) return FALSE;	/* Check filler */

-		}

-	} while (++s < 13);				/* Repeat until all chars in the entry are checked */

-

-	if ((dir[LDIR_Ord] & 0x40) && wc && lfnbuf[i])	/* Last segment matched but different length */

-		return FALSE;

-

-	return TRUE;					/* The part of LFN matched */

-}

-

-

-

-static

-BOOL pick_lfn (			/* TRUE:Succeeded, FALSE:Buffer overflow */

-	WCHAR *lfnbuf,		/* Pointer to the Unicode-LFN buffer */

-	BYTE *dir			/* Pointer to the directory entry */

-)

-{

-	int i, s;

-	WCHAR wc, uc;

-

-

-	i = ((dir[LDIR_Ord] & 0x3F) - 1) * 13;	/* Offset in the LFN buffer */

-

-	s = 0; wc = 1;

-	do {

-		uc = LD_WORD(dir+LfnOfs[s]);			/* Pick an LFN character from the entry */

-		if (wc) {	/* Last char has not been processed */

-			if (i >= _MAX_LFN) return FALSE;	/* Buffer overflow? */

-			lfnbuf[i++] = wc = uc;				/* Store it */

-		} else {

-			if (uc != 0xFFFF) return FALSE;		/* Check filler */

-		}

-	} while (++s < 13);						/* Read all character in the entry */

-

-	if (dir[LDIR_Ord] & 0x40) {				/* Put terminator if it is the last LFN part */

-		if (i >= _MAX_LFN) return FALSE;	/* Buffer overflow? */

-		lfnbuf[i] = 0;

-	}

-

-	return TRUE;

-}

-

-

-#if !_FS_READONLY

-static

-void fit_lfn (

-	const WCHAR *lfnbuf,	/* Pointer to the LFN buffer */

-	BYTE *dir,				/* Pointer to the directory entry */

-	BYTE ord,				/* LFN order (1-20) */

-	BYTE sum				/* SFN sum */

-)

-{

-	int i, s;

-	WCHAR wc;

-

-

-	dir[LDIR_Chksum] = sum;			/* Set check sum */

-	dir[LDIR_Attr] = AM_LFN;		/* Set attribute. LFN entry */

-	dir[LDIR_Type] = 0;

-	ST_WORD(dir+LDIR_FstClusLO, 0);

-

-	i = (ord - 1) * 13;				/* Get offset in the LFN buffer */

-	s = wc = 0;

-	do {

-		if (wc != 0xFFFF) wc = lfnbuf[i++];	/* Get an effective char */

-		ST_WORD(dir+LfnOfs[s], wc);	/* Put it */

-		if (!wc) wc = 0xFFFF;		/* Padding chars following last char */

-	} while (++s < 13);

-	if (wc == 0xFFFF || !lfnbuf[i]) ord |= 0x40;	/* Bottom LFN part is the start of LFN sequence */

-	dir[LDIR_Ord] = ord;			/* Set the LFN order */

-}

-

-#endif

-#endif

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Create numbered name                                                  */

-/*-----------------------------------------------------------------------*/

-#if _USE_LFN

-void gen_numname (

-	BYTE *dst,			/* Pointer to genartated SFN */

-	const BYTE *src,	/* Pointer to source SFN to be modified */

-	const WCHAR *lfn,	/* Pointer to LFN */

-	WORD num			/* Sequense number */

-)

-{

-	char ns[8];

-	int i, j;

-

-

-	mem_cpy(dst, src, 11);

-

-	if (num > 5) {	/* On many collisions, generate a hash number instead of sequencial number */

-		do num = (num >> 1) + (num << 15) + (WORD)*lfn++; while (*lfn);

-	}

-

-	/* itoa */

-	i = 7;

-	do {

-		ns[i--] = (num % 10) + '0';

-		num /= 10;

-	} while (num);

-	ns[i] = '~';

-

-	/* Append the number */

-	for (j = 0; j < i && dst[j] != ' '; j++) {

-		if (IsDBCS1(dst[j])) {

-			if (j == i - 1) break;

-			j++;

-		}

-	}

-	do {

-		dst[j++] = (i < 8) ? ns[i++] : ' ';

-	} while (j < 8);

-}

-#endif

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Calculate sum of an SFN                                               */

-/*-----------------------------------------------------------------------*/

-#if _USE_LFN

-static

-BYTE sum_sfn (

-	const BYTE *dir		/* Ptr to directory entry */

-)

-{

-	BYTE sum = 0;

-	int n = 11;

-

-	do sum = (sum >> 1) + (sum << 7) + *dir++; while (--n);

-	return sum;

-}

-#endif

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Directory handling - Find an object in the directory                  */

-/*-----------------------------------------------------------------------*/

-

-static

-FRESULT dir_find (

-	DIR *dj			/* Pointer to the directory object linked to the file name */

-)

-{

-	FRESULT res;

-	BYTE c, *dir;

-#if _USE_LFN

-	BYTE a, ord, sum;

-#endif

-

-	res = dir_seek(dj, 0);			/* Rewind directory object */

-	if (res != FR_OK) return res;

-

-#if _USE_LFN

-	ord = sum = 0xFF;

-#endif

-	do {

-		res = move_window(dj->fs, dj->sect);

-		if (res != FR_OK) break;

-		dir = dj->dir;					/* Ptr to the directory entry of current index */

-		c = dir[DIR_Name];

-		if (c == 0) { res = FR_NO_FILE; break; }	/* Reached to end of table */

-#if _USE_LFN	/* LFN configuration */

-		a = dir[DIR_Attr] & AM_MASK;

-		if (c == 0xE5 || ((a & AM_VOL) && a != AM_LFN)) {	/* An entry without valid data */

-			ord = 0xFF;

-		} else {

-			if (a == AM_LFN) {			/* An LFN entry is found */

-				if (dj->lfn) {

-					if (c & 0x40) {		/* Is it start of LFN sequence? */

-						sum = dir[LDIR_Chksum];

-						c &= 0xBF; ord = c;	/* LFN start order */

-						dj->lfn_idx = dj->index;

-					}

-					/* Check validity of the LFN entry and compare it with given name */

-					ord = (c == ord && sum == dir[LDIR_Chksum] && cmp_lfn(dj->lfn, dir)) ? ord - 1 : 0xFF;

-				}

-			} else {					/* An SFN entry is found */

-				if (!ord && sum == sum_sfn(dir)) break;	/* LFN matched? */

-				ord = 0xFF; dj->lfn_idx = 0xFFFF;	/* Reset LFN sequence */

-				if (!(dj->fn[NS] & NS_LOSS) && !mem_cmp(dir, dj->fn, 11)) break;	/* SFN matched? */

-			}

-		}

-#else		/* Non LFN configuration */

-		if (!(dir[DIR_Attr] & AM_VOL) && !mem_cmp(dir, dj->fn, 11)) /* Is it a valid entry? */

-			break;

-#endif

-		res = dir_next(dj, FALSE);		/* Next entry */

-	} while (res == FR_OK);

-

-	return res;

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Read an object from the directory                                     */

-/*-----------------------------------------------------------------------*/

-#if _FS_MINIMIZE <= 1

-static

-FRESULT dir_read (

-	DIR *dj			/* Pointer to the directory object that pointing the entry to be read */

-)

-{

-	FRESULT res;

-	BYTE c, *dir;

-#if _USE_LFN

-	BYTE a, ord = 0xFF, sum = 0xFF;

-#endif

-

-	res = FR_NO_FILE;

-	while (dj->sect) {

-		res = move_window(dj->fs, dj->sect);

-		if (res != FR_OK) break;

-		dir = dj->dir;					/* Ptr to the directory entry of current index */

-		c = dir[DIR_Name];

-		if (c == 0) { res = FR_NO_FILE; break; }	/* Reached to end of table */

-#if _USE_LFN	/* LFN configuration */

-		a = dir[DIR_Attr] & AM_MASK;

-		if (c == 0xE5 || (!_FS_RPATH && c == '.') || ((a & AM_VOL) && a != AM_LFN)) {	/* An entry without valid data */

-			ord = 0xFF;

-		} else {

-			if (a == AM_LFN) {			/* An LFN entry is found */

-				if (c & 0x40) {			/* Is it start of LFN sequence? */

-					sum = dir[LDIR_Chksum];

-					c &= 0xBF; ord = c;

-					dj->lfn_idx = dj->index;

-				}

-				/* Check LFN validity and capture it */

-				ord = (c == ord && sum == dir[LDIR_Chksum] && pick_lfn(dj->lfn, dir)) ? ord - 1 : 0xFF;

-			} else {					/* An SFN entry is found */

-				if (ord || sum != sum_sfn(dir))	/* Is there a valid LFN? */

-					dj->lfn_idx = 0xFFFF;		/* It has no LFN. */

-				break;

-			}

-		}

-#else		/* Non LFN configuration */

-		if (c != 0xE5 && (_FS_RPATH || c != '.') && !(dir[DIR_Attr] & AM_VOL))	/* Is it a valid entry? */

-			break;

-#endif

-		res = dir_next(dj, FALSE);				/* Next entry */

-		if (res != FR_OK) break;

-	}

-

-	if (res != FR_OK) dj->sect = 0;

-

-	return res;

-}

-#endif

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Register an object to the directory                                   */

-/*-----------------------------------------------------------------------*/

-#if !_FS_READONLY

-static

-FRESULT dir_register (	/* FR_OK:Successful, FR_DENIED:No free entry or too many SFN collision, FR_DISK_ERR:Disk error */

-	DIR *dj				/* Target directory with object name to be created */

-)

-{

-	FRESULT res;

-	BYTE c, *dir;

-#if _USE_LFN	/* LFN configuration */

-	WORD n, ne, is;

-	BYTE sn[12], *fn, sum;

-	WCHAR *lfn;

-

-

-	fn = dj->fn; lfn = dj->lfn;

-	mem_cpy(sn, fn, 12);

-

-	if (_FS_RPATH && (sn[NS] & NS_DOT)) return FR_INVALID_NAME;	/* Cannot create dot entry */

-

-	if (sn[NS] & NS_LOSS) {			/* When LFN is out of 8.3 format, generate a numbered name */

-		fn[NS] = 0; dj->lfn = NULL;			/* Find only SFN */

-		for (n = 1; n < 100; n++) {

-			gen_numname(fn, sn, lfn, n);	/* Generate a numbered name */

-			res = dir_find(dj);				/* Check if the name collides with existing SFN */

-			if (res != FR_OK) break;

-		}

-		if (n == 100) return FR_DENIED;		/* Abort if too many collisions */

-		if (res != FR_NO_FILE) return res;	/* Abort if the result is other than 'not collided' */

-		fn[NS] = sn[NS]; dj->lfn = lfn;

-	}

-

-	if (sn[NS] & NS_LFN) {			/* When LFN is to be created, reserve reserve an SFN + LFN entries. */

-		for (ne = 0; lfn[ne]; ne++) ;

-		ne = (ne + 25) / 13;

-	} else {						/* Otherwise reserve only an SFN entry. */

-		ne = 1;

-	}

-

-	/* Reserve contiguous entries */

-	res = dir_seek(dj, 0);

-	if (res != FR_OK) return res;

-	n = is = 0;

-	do {

-		res = move_window(dj->fs, dj->sect);

-		if (res != FR_OK) break;

-		c = *dj->dir;				/* Check the entry status */

-		if (c == 0xE5 || c == 0) {	/* Is it a blank entry? */

-			if (n == 0) is = dj->index;	/* First index of the contigulus entry */

-			if (++n == ne) break;	/* A contiguous entry that requiered count is found */

-		} else {

-			n = 0;					/* Not a blank entry. Restart to search */

-		}

-		res = dir_next(dj, TRUE);	/* Next entry with table streach */

-	} while (res == FR_OK);

-

-	if (res == FR_OK && ne > 1) {	/* Initialize LFN entry if needed */

-		res = dir_seek(dj, is);

-		if (res == FR_OK) {

-			sum = sum_sfn(dj->fn);	/* Sum of the SFN tied to the LFN */

-			ne--;

-			do {					/* Store LFN entries in bottom first */

-				res = move_window(dj->fs, dj->sect);

-				if (res != FR_OK) break;

-				fit_lfn(dj->lfn, dj->dir, (BYTE)ne, sum);

-				dj->fs->wflag = 1;

-				res = dir_next(dj, FALSE);	/* Next entry */

-			} while (res == FR_OK && --ne);

-		}

-	}

-

-#else	/* Non LFN configuration */

-	res = dir_seek(dj, 0);

-	if (res == FR_OK) {

-		do {	/* Find a blank entry for the SFN */

-			res = move_window(dj->fs, dj->sect);

-			if (res != FR_OK) break;

-			c = *dj->dir;

-			if (c == 0xE5 || c == 0) break;	/* Is it a blank entry? */

-			res = dir_next(dj, TRUE);		/* Next entry with table streach */

-		} while (res == FR_OK);

-	}

-#endif

-

-	if (res == FR_OK) {		/* Initialize the SFN entry */

-		res = move_window(dj->fs, dj->sect);

-		if (res == FR_OK) {

-			dir = dj->dir;

-			mem_set(dir, 0, 32);		/* Clean the entry */

-			mem_cpy(dir, dj->fn, 11);	/* Put SFN */

-			dir[DIR_NTres] = *(dj->fn+NS) & (NS_BODY | NS_EXT);	/* Put NT flag */

-			dj->fs->wflag = 1;

-		}

-	}

-

-	return res;

-}

-#endif /* !_FS_READONLY */

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Remove an object from the directory                                   */

-/*-----------------------------------------------------------------------*/

-#if !_FS_READONLY && !_FS_MINIMIZE

-static

-FRESULT dir_remove (	/* FR_OK: Successful, FR_DISK_ERR: A disk error */

-	DIR *dj				/* Directory object pointing the entry to be removed */

-)

-{

-	FRESULT res;

-#if _USE_LFN	/* LFN configuration */

-	WORD i;

-

-	i = dj->index;	/* SFN index */

-	res = dir_seek(dj, (WORD)((dj->lfn_idx == 0xFFFF) ? i : dj->lfn_idx));	/* Goto the SFN or top of the LFN entries */

-	if (res == FR_OK) {

-		do {

-			res = move_window(dj->fs, dj->sect);

-			if (res != FR_OK) break;

-			*dj->dir = 0xE5;			/* Mark the entry "deleted" */

-			dj->fs->wflag = 1;

-			if (dj->index >= i) break;	/* When reached SFN, all entries of the object has been deleted. */

-			res = dir_next(dj, FALSE);	/* Next entry */

-		} while (res == FR_OK);

-		if (res == FR_NO_FILE) res = FR_INT_ERR;

-	}

-

-#else			/* Non LFN configuration */

-	res = dir_seek(dj, dj->index);

-	if (res == FR_OK) {

-		res = move_window(dj->fs, dj->sect);

-		if (res == FR_OK) {

-			*dj->dir = 0xE5;			/* Mark the entry "deleted" */

-			dj->fs->wflag = 1;

-		}

-	}

-#endif

-

-	return res;

-}

-#endif /* !_FS_READONLY */

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Pick a segment and create the object name in directory form           */

-/*-----------------------------------------------------------------------*/

-

-static

-FRESULT create_name (

-	DIR *dj,			/* Pointer to the directory object */

-	const XCHAR **path	/* Pointer to pointer to the segment in the path string */

-)

-{

-#ifdef _EXCVT

-	static const BYTE cvt[] = _EXCVT;

-#endif

-

-#if _USE_LFN	/* LFN configuration */

-	BYTE b, cf;

-	WCHAR w, *lfn;

-	int i, ni, si, di;

-	const XCHAR *p;

-

-	/* Create LFN in Unicode */

-	si = di = 0;

-	p = *path;

-	lfn = dj->lfn;

-	for (;;) {

-		w = p[si++];					/* Get a character */

-		if (w < ' ' || w == '/' || w == '\\') break;	/* Break on end of segment */

-		if (di >= _MAX_LFN)				/* Reject too long name */

-			return FR_INVALID_NAME;

-#if !_LFN_UNICODE

-		w &= 0xFF;

-		if (IsDBCS1(w)) {				/* If it is a DBC 1st byte */

-			b = p[si++];				/* Get 2nd byte */

-			if (!IsDBCS2(b))			/* Reject invalid code for DBC */

-				return FR_INVALID_NAME;

-			w = (w << 8) + b;

-		}

-		w = ff_convert(w, 1);			/* Convert OEM to Unicode */

-		if (!w) return FR_INVALID_NAME;	/* Reject invalid code */

-#endif

-		if (w < 0x80 && chk_chr("\"*:<>\?|\x7F", w)) /* Reject illegal chars for LFN */

-			return FR_INVALID_NAME;

-		lfn[di++] = w;					/* Store the Unicode char */

-	}

-	*path = &p[si];						/* Rerurn pointer to the next segment */

-	cf = (w < ' ') ? NS_LAST : 0;		/* Set last segment flag if end of path */

-#if _FS_RPATH

-	if ((di == 1 && lfn[di - 1] == '.') || /* Is this a dot entry? */

-		(di == 2 && lfn[di - 1] == '.' && lfn[di - 2] == '.')) {

-		lfn[di] = 0;

-		for (i = 0; i < 11; i++)

-			dj->fn[i] = (i < di) ? '.' : ' ';

-		dj->fn[i] = cf | NS_DOT;		/* This is a dot entry */

-		return FR_OK;

-	}

-#endif

-	while (di) {						/* Strip trailing spaces and dots */

-		w = lfn[di - 1];

-		if (w != ' ' && w != '.') break;

-		di--;

-	}

-	if (!di) return FR_INVALID_NAME;	/* Reject null string */

-

-	lfn[di] = 0;						/* LFN is created */

-

-	/* Create SFN in directory form */

-	mem_set(dj->fn, ' ', 11);

-	for (si = 0; lfn[si] == ' ' || lfn[si] == '.'; si++) ;	/* Strip leading spaces and dots */

-	if (si) cf |= NS_LOSS | NS_LFN;

-	while (di && lfn[di - 1] != '.') di--;	/* Find extension (di<=si: no extension) */

-

-	b = i = 0; ni = 8;

-	for (;;) {

-		w = lfn[si++];					/* Get an LFN char */

-		if (!w) break;					/* Break on enf of the LFN */

-		if (w == ' ' || (w == '.' && si != di)) {	/* Remove spaces and dots */

-			cf |= NS_LOSS | NS_LFN; continue;

-		}

-

-		if (i >= ni || si == di) {		/* Extension or end of SFN */

-			if (ni == 11) {				/* Long extension */

-				cf |= NS_LOSS | NS_LFN; break;

-			}

-			if (si != di) cf |= NS_LOSS | NS_LFN;	/* Out of 8.3 format */

-			if (si > di) break;			/* No extension */

-			si = di; i = 8; ni = 11;	/* Enter extension section */

-			b <<= 2; continue;

-		}

-

-		if (w >= 0x80) {				/* Non ASCII char */

-#ifdef _EXCVT

-			w = ff_convert(w, 0);		/* Unicode -> OEM code */

-			if (w) w = cvt[w - 0x80];	/* Convert extended char to upper (SBCS) */

-#else

-			w = ff_convert(ff_wtoupper(w), 0);	/* Upper converted Unicode -> OEM code */

-#endif

-			cf |= NS_LFN;				/* Force create LFN entry */

-		}

-

-		if (_DF1S && w >= 0x100) {		/* Double byte char */

-			if (i >= ni - 1) {

-				cf |= NS_LOSS | NS_LFN; i = ni; continue;

-			}

-			dj->fn[i++] = (BYTE)(w >> 8);

-		} else {						/* Single byte char */

-			if (!w || chk_chr("+,;[=]", w)) {		/* Replace illegal chars for SFN */

-				w = '_'; cf |= NS_LOSS | NS_LFN;	/* Lossy conversion */

-			} else {

-				if (IsUpper(w)) {		/* ASCII large capital */

-					b |= 2;

-				} else {

-					if (IsLower(w)) {	/* ASCII small capital */

-						b |= 1; w -= 0x20;

-					}

-				}

-			}

-		}

-		dj->fn[i++] = (BYTE)w;

-	}

-

-	if (dj->fn[0] == 0xE5) dj->fn[0] = 0x05;	/* If the first char collides with deleted mark, replace it with 0x05 */

-

-	if (ni == 8) b <<= 2;

-	if ((b & 0x0C) == 0x0C || (b & 0x03) == 0x03)	/* Create LFN entry when there are composite capitals */

-		cf |= NS_LFN;

-	if (!(cf & NS_LFN)) {						/* When LFN is in 8.3 format without extended char, NT flags are created */

-		if ((b & 0x03) == 0x01) cf |= NS_EXT;	/* NT flag (Extension has only small capital) */

-		if ((b & 0x0C) == 0x04) cf |= NS_BODY;	/* NT flag (Filename has only small capital) */

-	}

-

-	dj->fn[NS] = cf;	/* SFN is created */

-

-	return FR_OK;

-

-

-#else	/* Non-LFN configuration */

-	BYTE b, c, d, *sfn;

-	int ni, si, i;

-	const char *p;

-

-	/* Create file name in directory form */

-	sfn = dj->fn;

-	mem_set(sfn, ' ', 11);

-	si = i = b = 0; ni = 8;

-	p = *path;

-#if _FS_RPATH

-	if (p[si] == '.') { /* Is this a dot entry? */

-		for (;;) {

-			c = p[si++];

-			if (c != '.' || si >= 3) break;

-			sfn[i++] = c;

-		}

-		if (c != '/' && c != '\\' && c > ' ') return FR_INVALID_NAME;

-		*path = &p[si];									/* Rerurn pointer to the next segment */

-		sfn[NS] = (c <= ' ') ? NS_LAST | NS_DOT : NS_DOT;	/* Set last segment flag if end of path */

-		return FR_OK;

-	}

-#endif

-	for (;;) {

-		c = p[si++];

-		if (c <= ' ' || c == '/' || c == '\\') break;	/* Break on end of segment */

-		if (c == '.' || i >= ni) {

-			if (ni != 8 || c != '.') return FR_INVALID_NAME;

-			i = 8; ni = 11;

-			b <<= 2; continue;

-		}

-		if (c >= 0x80) {				/* Extended char */

-#ifdef _EXCVT

-			c = cvt[c - 0x80];			/* Convert extend char (SBCS) */

-#else

-			b |= 3;						/* Eliminate NT flag if ext char is exist */

-#if !_DF1S	/* ASCII only cfg */

-			return FR_INVALID_NAME;

-#endif

-#endif

-		}

-		if (IsDBCS1(c)) {				/* DBC 1st byte? */

-			d = p[si++];				/* Get 2nd byte */

-			if (!IsDBCS2(d) || i >= ni - 1)	/* Reject invalid DBC */

-				return FR_INVALID_NAME;

-			sfn[i++] = c;

-			sfn[i++] = d;

-		} else {						/* Single byte code */

-			if (chk_chr(" \"*+,[=]|\x7F", c))	/* Reject illegal chrs for SFN */

-				return FR_INVALID_NAME;

-			if (IsUpper(c)) {			/* ASCII large capital? */

-				b |= 2;

-			} else {

-				if (IsLower(c)) {		/* ASCII small capital? */

-					b |= 1; c -= 0x20;

-				}

-			}

-			sfn[i++] = c;

-		}

-	}

-	*path = &p[si];						/* Rerurn pointer to the next segment */

-	c = (c <= ' ') ? NS_LAST : 0;		/* Set last segment flag if end of path */

-

-	if (!i) return FR_INVALID_NAME;		/* Reject null string */

-	if (sfn[0] == 0xE5) sfn[0] = 0x05;	/* When first char collides with 0xE5, replace it with 0x05 */

-

-	if (ni == 8) b <<= 2;

-	if ((b & 0x03) == 0x01) c |= NS_EXT;	/* NT flag (Extension has only small capital) */

-	if ((b & 0x0C) == 0x04) c |= NS_BODY;	/* NT flag (Filename has only small capital) */

-

-	sfn[NS] = c;		/* Store NT flag, File name is created */

-

-	return FR_OK;

-#endif

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Get file information from directory entry                             */

-/*-----------------------------------------------------------------------*/

-#if _FS_MINIMIZE <= 1

-static

-void get_fileinfo (		/* No return code */

-	DIR *dj,			/* Pointer to the directory object */

-	FILINFO *fno	 	/* Pointer to the file information to be filled */

-)

-{

-	int i;

-	BYTE c, nt, *dir;

-	char *p;

-

-

-	p = fno->fname;

-	if (dj->sect) {

-		dir = dj->dir;

-		nt = dir[DIR_NTres];		/* NT flag */

-		for (i = 0; i < 8; i++) {	/* Copy name body */

-			c = dir[i];

-			if (c == ' ') break;

-			if (c == 0x05) c = 0xE5;

-			if (_USE_LFN && (nt & NS_BODY) && IsUpper(c)) c += 0x20;

-			*p++ = c;

-		}

-		if (dir[8] != ' ') {		/* Copy name extension */

-			*p++ = '.';

-			for (i = 8; i < 11; i++) {

-				c = dir[i];

-				if (c == ' ') break;

-				if (_USE_LFN && (nt & NS_EXT) && IsUpper(c)) c += 0x20;

-				*p++ = c;

-			}

-		}

-		fno->fattrib = dir[DIR_Attr];				/* Attribute */

-		fno->fsize = LD_DWORD(dir+DIR_FileSize);	/* Size */

-		fno->fdate = LD_WORD(dir+DIR_WrtDate);		/* Date */

-		fno->ftime = LD_WORD(dir+DIR_WrtTime);		/* Time */

-	}

-	*p = 0;

-

-#if _USE_LFN

-	if (fno->lfname) {

-		XCHAR *tp = fno->lfname;

-		WCHAR w, *lfn;

-

-		i = 0;

-		if (dj->sect && dj->lfn_idx != 0xFFFF) {/* Get LFN if available */

-			lfn = dj->lfn;

-			while ((w = *lfn++) != 0) {			/* Get an LFN char */

-#if !_LFN_UNICODE

-				w = ff_convert(w, 0);			/* Unicode -> OEM conversion */

-				if (!w) { i = 0; break; }		/* Could not convert, no LFN */

-				if (_DF1S && w >= 0x100)		/* Put 1st byte if it is a DBC */

-					tp[i++] = (XCHAR)(w >> 8);

-#endif

-				if (i >= fno->lfsize - 1) { i = 0; break; }	/* Buffer overrun, no LFN */

-				tp[i++] = (XCHAR)w;

-			}

-		}

-		tp[i] = 0;	/* Terminator */

-	}

-#endif

-}

-#endif /* _FS_MINIMIZE <= 1 */

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Follow a file path                                                    */

-/*-----------------------------------------------------------------------*/

-

-static

-FRESULT follow_path (	/* FR_OK(0): successful, !=0: error code */

-	DIR *dj,			/* Directory object to return last directory and found object */

-	const XCHAR *path	/* Full-path string to find a file or directory */

-)

-{

-	FRESULT res;

-	BYTE *dir, last;

-

-

-	while (!_USE_LFN && *path == ' ') path++;	/* Skip leading spaces */

-#if _FS_RPATH

-	if (*path == '/' || *path == '\\') { /* There is a heading separator */

-		path++;	dj->sclust = 0;		/* Strip it and start from the root dir */

-	} else {							/* No heading saparator */

-		dj->sclust = dj->fs->cdir;	/* Start from the current dir */

-	}

-#else

-	if (*path == '/' || *path == '\\')	/* Strip heading separator if exist */

-		path++;

-	dj->sclust = 0;						/* Start from the root dir */

-#endif

-

-	if ((UINT)*path < ' ') {			/* Null path means the start directory itself */

-		res = dir_seek(dj, 0);

-		dj->dir = NULL;

-

-	} else {							/* Follow path */

-		for (;;) {

-			res = create_name(dj, &path);	/* Get a segment */

-			if (res != FR_OK) break;

-			res = dir_find(dj);				/* Find it */

-			last = *(dj->fn+NS) & NS_LAST;

-			if (res != FR_OK) {				/* Could not find the object */

-				if (res == FR_NO_FILE && !last)

-					res = FR_NO_PATH;

-				break;

-			}

-			if (last) break;				/* Last segment match. Function completed. */

-			dir = dj->dir;					/* There is next segment. Follow the sub directory */

-			if (!(dir[DIR_Attr] & AM_DIR)) { /* Cannot follow because it is a file */

-				res = FR_NO_PATH; break;

-			}

-			dj->sclust = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);

-		}

-	}

-

-	return res;

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Load boot record and check if it is an FAT boot record                */

-/*-----------------------------------------------------------------------*/

-

-static

-BYTE check_fs (	/* 0:The FAT boot record, 1:Valid boot record but not an FAT, 2:Not a boot record, 3:Error */

-	FATFS *fs,	/* File system object */

-	DWORD sect	/* Sector# (lba) to check if it is an FAT boot record or not */

-)

-{

-	if (disk_read(fs->drive, fs->win, sect, 1) != RES_OK)	/* Load boot record */

-		return 3;

-	if (LD_WORD(&fs->win[BS_55AA]) != 0xAA55)		/* Check record signature (always placed at offset 510 even if the sector size is >512) */

-		return 2;

-

-	if ((LD_DWORD(&fs->win[BS_FilSysType]) & 0xFFFFFF) == 0x544146)	/* Check "FAT" string */

-		return 0;

-	if ((LD_DWORD(&fs->win[BS_FilSysType32]) & 0xFFFFFF) == 0x544146)

-		return 0;

-

-	return 1;

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Make sure that the file system is valid                               */

-/*-----------------------------------------------------------------------*/

-

-

-FRESULT chk_mounted (	/* FR_OK(0): successful, !=0: any error occured */

-	const XCHAR **path,	/* Pointer to pointer to the path name (drive number) */

-	FATFS **rfs,		/* Pointer to pointer to the found file system object */

-	BYTE chk_wp			/* !=0: Check media write protection for write access */

-)

-{

-	BYTE fmt, *tbl;

-	UINT vol;

-	DSTATUS stat;

-	DWORD bsect, fsize, tsect, mclst;

-	const XCHAR *p = *path;

-	FATFS *fs;

-

-	/* Get logical drive number from the path name */

-	vol = p[0] - '0';				/* Is there a drive number? */

-	if (vol <= 9 && p[1] == ':') {	/* Found a drive number, get and strip it */

-		p += 2; *path = p;			/* Return pointer to the path name */

-	} else {						/* No drive number is given */

-#if _FS_RPATH

-		vol = Drive;				/* Use current drive */

-#else

-		vol = 0;					/* Use drive 0 */

-#endif

-	}

-

-	/* Check if the logical drive is valid or not */

-	if (vol >= _DRIVES) 			/* Is the drive number valid? */

-		return FR_INVALID_DRIVE;

-	*rfs = fs = FatFs[vol];			/* Returen pointer to the corresponding file system object */

-	if (!fs) return FR_NOT_ENABLED;	/* Is the file system object available? */

-

-	ENTER_FF(fs);					/* Lock file system */

-

-	if (fs->fs_type) {				/* If the logical drive has been mounted */

-		stat = disk_status(fs->drive);

-		if (!(stat & STA_NOINIT)) {	/* and the physical drive is kept initialized (has not been changed), */

-#if !_FS_READONLY

-			if (chk_wp && (stat & STA_PROTECT))	/* Check write protection if needed */

-				return FR_WRITE_PROTECTED;

-#endif

-			return FR_OK;			/* The file system object is valid */

-		}

-	}

-

-	/* The logical drive must be mounted. Following code attempts to mount the volume */

-

-	fs->fs_type = 0;					/* Clear the file system object */

-	fs->drive = (BYTE)LD2PD(vol);		/* Bind the logical drive and a physical drive */

-	stat = disk_initialize(fs->drive);	/* Initialize low level disk I/O layer */

-	if (stat & STA_NOINIT)				/* Check if the drive is ready */

-		return FR_NOT_READY;

-#if _MAX_SS != 512						/* Get disk sector size if needed */

-	if (disk_ioctl(fs->drive, GET_SECTOR_SIZE, &SS(fs)) != RES_OK || SS(fs) > _MAX_SS)

-		return FR_NO_FILESYSTEM;

-#endif

-#if !_FS_READONLY

-	if (chk_wp && (stat & STA_PROTECT))	/* Check disk write protection if needed */

-		return FR_WRITE_PROTECTED;

-#endif

-	/* Search FAT partition on the drive */

-	fmt = check_fs(fs, bsect = 0);		/* Check sector 0 as an SFD format */

-	if (fmt == 1) {						/* Not an FAT boot record, it may be patitioned */

-		/* Check a partition listed in top of the partition table */

-		tbl = &fs->win[MBR_Table + LD2PT(vol) * 16];	/* Partition table */

-		if (tbl[4]) {									/* Is the partition existing? */

-			bsect = LD_DWORD(&tbl[8]);					/* Partition offset in LBA */

-			fmt = check_fs(fs, bsect);					/* Check the partition */

-		}

-	}

-	if (fmt == 3) return FR_DISK_ERR;

-	if (fmt || LD_WORD(fs->win+BPB_BytsPerSec) != SS(fs))	/* No valid FAT patition is found */

-		return FR_NO_FILESYSTEM;

-

-	/* Initialize the file system object */

-	fsize = LD_WORD(fs->win+BPB_FATSz16);				/* Number of sectors per FAT */

-	if (!fsize) fsize = LD_DWORD(fs->win+BPB_FATSz32);

-	fs->sects_fat = fsize;

-	fs->n_fats = fs->win[BPB_NumFATs];					/* Number of FAT copies */

-	fsize *= fs->n_fats;								/* (Number of sectors in FAT area) */

-	fs->fatbase = bsect + LD_WORD(fs->win+BPB_RsvdSecCnt); /* FAT start sector (lba) */

-	fs->csize = fs->win[BPB_SecPerClus];				/* Number of sectors per cluster */

-	fs->n_rootdir = LD_WORD(fs->win+BPB_RootEntCnt);	/* Nmuber of root directory entries */

-	tsect = LD_WORD(fs->win+BPB_TotSec16);				/* Number of sectors on the volume */

-	if (!tsect) tsect = LD_DWORD(fs->win+BPB_TotSec32);

-	fs->max_clust = mclst = (tsect						/* Last cluster# + 1 (Number of clusters + 2) */

-		- LD_WORD(fs->win+BPB_RsvdSecCnt) - fsize - fs->n_rootdir / (SS(fs)/32)

-		) / fs->csize + 2;

-

-	fmt = FS_FAT12;										/* Determine the FAT sub type */

-	if (mclst >= 0xFF7) fmt = FS_FAT16;					/* Number of clusters >= 0xFF5 */

-	if (mclst >= 0xFFF7) fmt = FS_FAT32;				/* Number of clusters >= 0xFFF5 */

-

-	if (fmt == FS_FAT32)

-		fs->dirbase = LD_DWORD(fs->win+BPB_RootClus);	/* Root directory start cluster */

-	else

-		fs->dirbase = fs->fatbase + fsize;				/* Root directory start sector (lba) */

-	fs->database = fs->fatbase + fsize + fs->n_rootdir / (SS(fs)/32);	/* Data start sector (lba) */

-

-#if !_FS_READONLY

-	/* Initialize allocation information */

-	fs->free_clust = 0xFFFFFFFF;

-	fs->wflag = 0;

-	/* Get fsinfo if needed */

-	if (fmt == FS_FAT32) {

-	 	fs->fsi_flag = 0;

-		fs->fsi_sector = bsect + LD_WORD(fs->win+BPB_FSInfo);

-		if (disk_read(fs->drive, fs->win, fs->fsi_sector, 1) == RES_OK &&

-			LD_WORD(fs->win+BS_55AA) == 0xAA55 &&

-			LD_DWORD(fs->win+FSI_LeadSig) == 0x41615252 &&

-			LD_DWORD(fs->win+FSI_StrucSig) == 0x61417272) {

-			fs->last_clust = LD_DWORD(fs->win+FSI_Nxt_Free);

-			fs->free_clust = LD_DWORD(fs->win+FSI_Free_Count);

-		}

-	}

-#endif

-	fs->fs_type = fmt;		/* FAT sub-type */

-	fs->winsect = 0;		/* Invalidate sector cache */

-#if _FS_RPATH

-	fs->cdir = 0;			/* Current directory (root dir) */

-#endif

-	fs->id = ++Fsid;		/* File system mount ID */

-

-	return FR_OK;

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Check if the file/dir object is valid or not                          */

-/*-----------------------------------------------------------------------*/

-

-static

-FRESULT validate (	/* FR_OK(0): The object is valid, !=0: Invalid */

-	FATFS *fs,		/* Pointer to the file system object */

-	WORD id			/* Member id of the target object to be checked */

-)

-{

-	if (!fs || !fs->fs_type || fs->id != id)

-		return FR_INVALID_OBJECT;

-

-	ENTER_FF(fs);		/* Lock file system */

-

-	if (disk_status(fs->drive) & STA_NOINIT)

-		return FR_NOT_READY;

-

-	return FR_OK;

-}

-

-

-

-

-/*--------------------------------------------------------------------------

-

-   Public Functions

-

---------------------------------------------------------------------------*/

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Mount/Unmount a Locical Drive                                         */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_mount (

-	BYTE vol,		/* Logical drive number to be mounted/unmounted */

-	FATFS *fs		/* Pointer to new file system object (NULL for unmount)*/

-)

-{

-	FATFS *rfs;

-

-

-	if (vol >= _DRIVES)				/* Check if the drive number is valid */

-		return FR_INVALID_DRIVE;

-	rfs = FatFs[vol];				/* Get current fs object */

-

-	if (rfs) {

-#if _FS_REENTRANT					/* Discard sync object of the current volume */

-		if (!ff_del_syncobj(rfs->sobj)) return FR_INT_ERR;

-#endif

-		rfs->fs_type = 0;			/* Clear old fs object */

-	}

-

-	if (fs) {

-		fs->fs_type = 0;			/* Clear new fs object */

-#if _FS_REENTRANT					/* Create sync object for the new volume */

-		if (!ff_cre_syncobj(vol, &fs->sobj)) return FR_INT_ERR;

-#endif

-	}

-	FatFs[vol] = fs;				/* Register new fs object */

-

-	return FR_OK;

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Open or Create a File                                                 */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_open (

-	FIL *fp,			/* Pointer to the blank file object */

-	const XCHAR *path,	/* Pointer to the file name */

-	BYTE mode			/* Access mode and file open mode flags */

-)

-{

-	FRESULT res;

-	DIR dj;

-	NAMEBUF(sfn, lfn);

-	BYTE *dir;

-

-

-	fp->fs = NULL;		/* Clear file object */

-#if !_FS_READONLY

-	mode &= (FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW);

-	res = chk_mounted(&path, &dj.fs, (BYTE)(mode & (FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)));

-#else

-	mode &= FA_READ;

-	res = chk_mounted(&path, &dj.fs, 0);

-#endif

-	if (res != FR_OK) LEAVE_FF(dj.fs, res);

-	INITBUF(dj, sfn, lfn);

-	res = follow_path(&dj, path);	/* Follow the file path */

-

-#if !_FS_READONLY

-	/* Create or Open a file */

-	if (mode & (FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)) {

-		DWORD ps, cl;

-

-		if (res != FR_OK) {			/* No file, create new */

-			if (res == FR_NO_FILE)	/* There is no file to open, create a new entry */

-				res = dir_register(&dj);

-			if (res != FR_OK) LEAVE_FF(dj.fs, res);

-			mode |= FA_CREATE_ALWAYS;

-			dir = dj.dir;			/* Created entry (SFN entry) */

-		}

-		else {						/* Any object is already existing */

-			if (mode & FA_CREATE_NEW)			/* Cannot create new */

-				LEAVE_FF(dj.fs, FR_EXIST);

-			dir = dj.dir;

-			if (!dir || (dir[DIR_Attr] & (AM_RDO | AM_DIR)))	/* Cannot overwrite it (R/O or DIR) */

-				LEAVE_FF(dj.fs, FR_DENIED);

-			if (mode & FA_CREATE_ALWAYS) {		/* Resize it to zero on over write mode */

-				cl = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);	/* Get start cluster */

-				ST_WORD(dir+DIR_FstClusHI, 0);	/* cluster = 0 */

-				ST_WORD(dir+DIR_FstClusLO, 0);

-				ST_DWORD(dir+DIR_FileSize, 0);	/* size = 0 */

-				dj.fs->wflag = 1;

-				ps = dj.fs->winsect;			/* Remove the cluster chain */

-				if (cl) {

-					res = remove_chain(dj.fs, cl);

-					if (res) LEAVE_FF(dj.fs, res);

-					dj.fs->last_clust = cl - 1;	/* Reuse the cluster hole */

-				}

-				res = move_window(dj.fs, ps);

-				if (res != FR_OK) LEAVE_FF(dj.fs, res);

-			}

-		}

-		if (mode & FA_CREATE_ALWAYS) {

-			dir[DIR_Attr] = 0;					/* Reset attribute */

-			ps = get_fattime();

-			ST_DWORD(dir+DIR_CrtTime, ps);		/* Created time */

-			dj.fs->wflag = 1;

-			mode |= FA__WRITTEN;				/* Set file changed flag */

-		}

-	}

-	/* Open an existing file */

-	else {

-#endif /* !_FS_READONLY */

-		if (res != FR_OK) LEAVE_FF(dj.fs, res);	/* Follow failed */

-		dir = dj.dir;

-		if (!dir || (dir[DIR_Attr] & AM_DIR))	/* It is a directory */

-			LEAVE_FF(dj.fs, FR_NO_FILE);

-#if !_FS_READONLY

-		if ((mode & FA_WRITE) && (dir[DIR_Attr] & AM_RDO)) /* R/O violation */

-			LEAVE_FF(dj.fs, FR_DENIED);

-	}

-	fp->dir_sect = dj.fs->winsect;		/* Pointer to the directory entry */

-	fp->dir_ptr = dj.dir;

-#endif

-	fp->flag = mode;					/* File access mode */

-	fp->org_clust =						/* File start cluster */

-		((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);

-	fp->fsize = LD_DWORD(dir+DIR_FileSize);	/* File size */

-	fp->fptr = 0; fp->csect = 255;		/* File pointer */

-	fp->dsect = 0;

-	fp->fs = dj.fs; fp->id = dj.fs->id;	/* Owner file system object of the file */

-

-	LEAVE_FF(dj.fs, FR_OK);

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Read File                                                             */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_read (

-	FIL *fp, 		/* Pointer to the file object */

-	void *buff,		/* Pointer to data buffer */

-	UINT btr,		/* Number of bytes to read */

-	UINT *br		/* Pointer to number of bytes read */

-)

-{

-	FRESULT res;

-	DWORD clst, sect, remain;

-	UINT rcnt, cc;

-	BYTE *rbuff = buff;

-

-

-	*br = 0;	/* Initialize bytes read */

-

-	res = validate(fp->fs, fp->id);					/* Check validity of the object */

-	if (res != FR_OK) LEAVE_FF(fp->fs, res);

-	if (fp->flag & FA__ERROR)						/* Check abort flag */

-		LEAVE_FF(fp->fs, FR_INT_ERR);

-	if (!(fp->flag & FA_READ)) 						/* Check access mode */

-		LEAVE_FF(fp->fs, FR_DENIED);

-	remain = fp->fsize - fp->fptr;

-	if (btr > remain) btr = (UINT)remain;			/* Truncate btr by remaining bytes */

-

-	for ( ;  btr;									/* Repeat until all data transferred */

-		rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) {

-		if ((fp->fptr % SS(fp->fs)) == 0) {			/* On the sector boundary? */

-			if (fp->csect >= fp->fs->csize) {		/* On the cluster boundary? */

-				clst = (fp->fptr == 0) ?			/* On the top of the file? */

-					fp->org_clust : get_fat(fp->fs, fp->curr_clust);

-				if (clst <= 1) ABORT(fp->fs, FR_INT_ERR);

-				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);

-				fp->curr_clust = clst;				/* Update current cluster */

-				fp->csect = 0;						/* Reset sector offset in the cluster */

-			}

-			sect = clust2sect(fp->fs, fp->curr_clust);	/* Get current sector */

-			if (!sect) ABORT(fp->fs, FR_INT_ERR);

-			sect += fp->csect;

-			cc = btr / SS(fp->fs);					/* When remaining bytes >= sector size, */

-			if (cc) {								/* Read maximum contiguous sectors directly */

-				if (fp->csect + cc > fp->fs->csize)	/* Clip at cluster boundary */

-					cc = fp->fs->csize - fp->csect;

-				if (disk_read(fp->fs->drive, rbuff, sect, (BYTE)cc) != RES_OK)

-					ABORT(fp->fs, FR_DISK_ERR);

-#if !_FS_READONLY && _FS_MINIMIZE <= 2

-#if _FS_TINY

-				if (fp->fs->wflag && fp->fs->winsect - sect < cc)		/* Replace one of the read sectors with cached data if it contains a dirty sector */

-					mem_cpy(rbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), fp->fs->win, SS(fp->fs));

-#else

-				if ((fp->flag & FA__DIRTY) && fp->dsect - sect < cc)	/* Replace one of the read sectors with cached data if it contains a dirty sector */

-					mem_cpy(rbuff + ((fp->dsect - sect) * SS(fp->fs)), fp->buf, SS(fp->fs));

-#endif

-#endif

-				fp->csect += (BYTE)cc;				/* Next sector address in the cluster */

-				rcnt = SS(fp->fs) * cc;				/* Number of bytes transferred */

-				continue;

-			}

-#if !_FS_TINY

-#if !_FS_READONLY

-			if (fp->flag & FA__DIRTY) {			/* Write sector I/O buffer if needed */

-				if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)

-					ABORT(fp->fs, FR_DISK_ERR);

-				fp->flag &= ~FA__DIRTY;

-			}

-#endif

-			if (fp->dsect != sect) {			/* Fill sector buffer with file data */

-				if (disk_read(fp->fs->drive, fp->buf, sect, 1) != RES_OK)

-					ABORT(fp->fs, FR_DISK_ERR);

-			}

-#endif

-			fp->dsect = sect;

-			fp->csect++;							/* Next sector address in the cluster */

-		}

-		rcnt = SS(fp->fs) - (fp->fptr % SS(fp->fs));	/* Get partial sector data from sector buffer */

-		if (rcnt > btr) rcnt = btr;

-#if _FS_TINY

-		if (move_window(fp->fs, fp->dsect))			/* Move sector window */

-			ABORT(fp->fs, FR_DISK_ERR);

-		mem_cpy(rbuff, &fp->fs->win[fp->fptr % SS(fp->fs)], rcnt);	/* Pick partial sector */

-#else

-		mem_cpy(rbuff, &fp->buf[fp->fptr % SS(fp->fs)], rcnt);	/* Pick partial sector */

-#endif

-	}

-

-	LEAVE_FF(fp->fs, FR_OK);

-}

-

-

-

-

-#if !_FS_READONLY

-/*-----------------------------------------------------------------------*/

-/* Write File                                                            */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_write (

-	FIL *fp,			/* Pointer to the file object */

-	const void *buff,	/* Pointer to the data to be written */

-	UINT btw,			/* Number of bytes to write */

-	UINT *bw			/* Pointer to number of bytes written */

-)

-{

-	FRESULT res;

-	DWORD clst, sect;

-	UINT wcnt, cc;

-	const BYTE *wbuff = buff;

-

-

-	*bw = 0;	/* Initialize bytes written */

-

-	res = validate(fp->fs, fp->id);					/* Check validity of the object */

-	if (res != FR_OK) LEAVE_FF(fp->fs, res);

-	if (fp->flag & FA__ERROR)						/* Check abort flag */

-		LEAVE_FF(fp->fs, FR_INT_ERR);

-	if (!(fp->flag & FA_WRITE))						/* Check access mode */

-		LEAVE_FF(fp->fs, FR_DENIED);

-	if (fp->fsize + btw < fp->fsize) btw = 0;		/* File size cannot reach 4GB */

-

-	for ( ;  btw;									/* Repeat until all data transferred */

-		wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) {

-		if ((fp->fptr % SS(fp->fs)) == 0) {			/* On the sector boundary? */

-			if (fp->csect >= fp->fs->csize) {		/* On the cluster boundary? */

-				if (fp->fptr == 0) {				/* On the top of the file? */

-					clst = fp->org_clust;			/* Follow from the origin */

-					if (clst == 0)					/* When there is no cluster chain, */

-						fp->org_clust = clst = create_chain(fp->fs, 0);	/* Create a new cluster chain */

-				} else {							/* Middle or end of the file */

-					clst = create_chain(fp->fs, fp->curr_clust);			/* Follow or streach cluster chain */

-				}

-				if (clst == 0) break;				/* Could not allocate a new cluster (disk full) */

-				if (clst == 1) ABORT(fp->fs, FR_INT_ERR);

-				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);

-				fp->curr_clust = clst;				/* Update current cluster */

-				fp->csect = 0;						/* Reset sector address in the cluster */

-			}

-#if _FS_TINY

-			if (fp->fs->winsect == fp->dsect && move_window(fp->fs, 0))	/* Write back data buffer prior to following direct transfer */

-				ABORT(fp->fs, FR_DISK_ERR);

-#else

-			if (fp->flag & FA__DIRTY) {		/* Write back data buffer prior to following direct transfer */

-				if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)

-					ABORT(fp->fs, FR_DISK_ERR);

-				fp->flag &= ~FA__DIRTY;

-			}

-#endif

-			sect = clust2sect(fp->fs, fp->curr_clust);	/* Get current sector */

-			if (!sect) ABORT(fp->fs, FR_INT_ERR);

-			sect += fp->csect;

-			cc = btw / SS(fp->fs);					/* When remaining bytes >= sector size, */

-			if (cc) {								/* Write maximum contiguous sectors directly */

-				if (fp->csect + cc > fp->fs->csize)	/* Clip at cluster boundary */

-					cc = fp->fs->csize - fp->csect;

-				if (disk_write(fp->fs->drive, wbuff, sect, (BYTE)cc) != RES_OK)

-					ABORT(fp->fs, FR_DISK_ERR);

-#if _FS_TINY

-				if (fp->fs->winsect - sect < cc) {	/* Refill sector cache if it gets dirty by the direct write */

-					mem_cpy(fp->fs->win, wbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), SS(fp->fs));

-					fp->fs->wflag = 0;

-				}

-#else

-				if (fp->dsect - sect < cc) {		/* Refill sector cache if it gets dirty by the direct write */

-					mem_cpy(fp->buf, wbuff + ((fp->dsect - sect) * SS(fp->fs)), SS(fp->fs));

-					fp->flag &= ~FA__DIRTY;

-				}

-#endif

-				fp->csect += (BYTE)cc;				/* Next sector address in the cluster */

-				wcnt = SS(fp->fs) * cc;				/* Number of bytes transferred */

-				continue;

-			}

-#if _FS_TINY

-			if (fp->fptr >= fp->fsize) {			/* Avoid silly buffer filling at growing edge */

-				if (move_window(fp->fs, 0)) ABORT(fp->fs, FR_DISK_ERR);

-				fp->fs->winsect = sect;

-			}

-#else

-			if (fp->dsect != sect) {				/* Fill sector buffer with file data */

-				if (fp->fptr < fp->fsize &&

-					disk_read(fp->fs->drive, fp->buf, sect, 1) != RES_OK)

-						ABORT(fp->fs, FR_DISK_ERR);

-			}

-#endif

-			fp->dsect = sect;

-			fp->csect++;							/* Next sector address in the cluster */

-		}

-		wcnt = SS(fp->fs) - (fp->fptr % SS(fp->fs));	/* Put partial sector into file I/O buffer */

-		if (wcnt > btw) wcnt = btw;

-#if _FS_TINY

-		if (move_window(fp->fs, fp->dsect))			/* Move sector window */

-			ABORT(fp->fs, FR_DISK_ERR);

-		mem_cpy(&fp->fs->win[fp->fptr % SS(fp->fs)], wbuff, wcnt);	/* Fit partial sector */

-		fp->fs->wflag = 1;

-#else

-		mem_cpy(&fp->buf[fp->fptr % SS(fp->fs)], wbuff, wcnt);	/* Fit partial sector */

-		fp->flag |= FA__DIRTY;

-#endif

-	}

-

-	if (fp->fptr > fp->fsize) fp->fsize = fp->fptr;	/* Update file size if needed */

-	fp->flag |= FA__WRITTEN;						/* Set file changed flag */

-

-	LEAVE_FF(fp->fs, FR_OK);

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Synchronize the File Object                                           */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_sync (

-	FIL *fp		/* Pointer to the file object */

-)

-{

-	FRESULT res;

-	DWORD tim;

-	BYTE *dir;

-

-

-	res = validate(fp->fs, fp->id);		/* Check validity of the object */

-	if (res == FR_OK) {

-		if (fp->flag & FA__WRITTEN) {	/* Has the file been written? */

-#if !_FS_TINY	/* Write-back dirty buffer */

-			if (fp->flag & FA__DIRTY) {

-				if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)

-					LEAVE_FF(fp->fs, FR_DISK_ERR);

-				fp->flag &= ~FA__DIRTY;

-			}

-#endif

-			/* Update the directory entry */

-			res = move_window(fp->fs, fp->dir_sect);

-			if (res == FR_OK) {

-				dir = fp->dir_ptr;

-				dir[DIR_Attr] |= AM_ARC;					/* Set archive bit */

-				ST_DWORD(dir+DIR_FileSize, fp->fsize);		/* Update file size */

-				ST_WORD(dir+DIR_FstClusLO, fp->org_clust);	/* Update start cluster */

-				ST_WORD(dir+DIR_FstClusHI, fp->org_clust >> 16);

-				tim = get_fattime();			/* Updated time */

-				ST_DWORD(dir+DIR_WrtTime, tim);

-				fp->flag &= ~FA__WRITTEN;

-				fp->fs->wflag = 1;

-				res = sync(fp->fs);

-			}

-		}

-	}

-

-	LEAVE_FF(fp->fs, res);

-}

-

-#endif /* !_FS_READONLY */

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Close File                                                            */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_close (

-	FIL *fp		/* Pointer to the file object to be closed */

-)

-{

-	FRESULT res;

-

-

-#if _FS_READONLY

-	res = validate(fp->fs, fp->id);

-	if (res == FR_OK) fp->fs = NULL;

-	LEAVE_FF(fp->fs, res);

-#else

-	res = f_sync(fp);

-	if (res == FR_OK) fp->fs = NULL;

-	return res;

-#endif

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Change Current Drive/Directory                                        */

-/*-----------------------------------------------------------------------*/

-

-#if _FS_RPATH

-

-FRESULT f_chdrive (

-	BYTE drv		/* Drive number */

-)

-{

-	if (drv >= _DRIVES) return FR_INVALID_DRIVE;

-

-	Drive = drv;

-

-	return FR_OK;

-}

-

-

-

-

-FRESULT f_chdir (

-	const XCHAR *path	/* Pointer to the directory path */

-)

-{

-	FRESULT res;

-	DIR dj;

-	NAMEBUF(sfn, lfn);

-	BYTE *dir;

-

-

-	res = chk_mounted(&path, &dj.fs, 0);

-	if (res == FR_OK) {

-		INITBUF(dj, sfn, lfn);

-		res = follow_path(&dj, path);		/* Follow the file path */

-		if (res == FR_OK) {					/* Follow completed */

-			dir = dj.dir;					/* Pointer to the entry */

-			if (!dir) {

-				dj.fs->cdir = 0;			/* No entry (root dir) */

-			} else {

-				if (dir[DIR_Attr] & AM_DIR)	/* Reached to the dir */

-					dj.fs->cdir = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);

-				else

-					res = FR_NO_PATH;		/* Could not reach the dir (it is a file) */

-			}

-		}

-		if (res == FR_NO_FILE) res = FR_NO_PATH;

-	}

-

-	LEAVE_FF(dj.fs, res);

-}

-

-#endif

-

-

-

-#if _FS_MINIMIZE <= 2

-/*-----------------------------------------------------------------------*/

-/* Seek File R/W Pointer                                                 */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_lseek (

-	FIL *fp,		/* Pointer to the file object */

-	DWORD ofs		/* File pointer from top of file */

-)

-{

-	FRESULT res;

-	DWORD clst, bcs, nsect, ifptr;

-

-

-	res = validate(fp->fs, fp->id);		/* Check validity of the object */

-	if (res != FR_OK) LEAVE_FF(fp->fs, res);

-	if (fp->flag & FA__ERROR)			/* Check abort flag */

-		LEAVE_FF(fp->fs, FR_INT_ERR);

-	if (ofs > fp->fsize					/* In read-only mode, clip offset with the file size */

-#if !_FS_READONLY

-		 && !(fp->flag & FA_WRITE)

-#endif

-		) ofs = fp->fsize;

-

-	ifptr = fp->fptr;

-	fp->fptr = nsect = 0; fp->csect = 255;

-	if (ofs > 0) {

-		bcs = (DWORD)fp->fs->csize * SS(fp->fs);	/* Cluster size (byte) */

-		if (ifptr > 0 &&

-			(ofs - 1) / bcs >= (ifptr - 1) / bcs) {	/* When seek to same or following cluster, */

-			fp->fptr = (ifptr - 1) & ~(bcs - 1);	/* start from the current cluster */

-			ofs -= fp->fptr;

-			clst = fp->curr_clust;

-		} else {									/* When seek to back cluster, */

-			clst = fp->org_clust;					/* start from the first cluster */

-#if !_FS_READONLY

-			if (clst == 0) {						/* If no cluster chain, create a new chain */

-				clst = create_chain(fp->fs, 0);

-				if (clst == 1) ABORT(fp->fs, FR_INT_ERR);

-				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);

-				fp->org_clust = clst;

-			}

-#endif

-			fp->curr_clust = clst;

-		}

-		if (clst != 0) {

-			while (ofs > bcs) {						/* Cluster following loop */

-#if !_FS_READONLY

-				if (fp->flag & FA_WRITE) {			/* Check if in write mode or not */

-					clst = create_chain(fp->fs, clst);	/* Force streached if in write mode */

-					if (clst == 0) {				/* When disk gets full, clip file size */

-						ofs = bcs; break;

-					}

-				} else

-#endif

-					clst = get_fat(fp->fs, clst);	/* Follow cluster chain if not in write mode */

-				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);

-				if (clst <= 1 || clst >= fp->fs->max_clust) ABORT(fp->fs, FR_INT_ERR);

-				fp->curr_clust = clst;

-				fp->fptr += bcs;

-				ofs -= bcs;

-			}

-			fp->fptr += ofs;

-			fp->csect = (BYTE)(ofs / SS(fp->fs));	/* Sector offset in the cluster */

-			if (ofs % SS(fp->fs)) {

-				nsect = clust2sect(fp->fs, clst);	/* Current sector */

-				if (!nsect) ABORT(fp->fs, FR_INT_ERR);

-				nsect += fp->csect;

-				fp->csect++;

-			}

-		}

-	}

-	if (fp->fptr % SS(fp->fs) && nsect != fp->dsect) {

-#if !_FS_TINY

-#if !_FS_READONLY

-		if (fp->flag & FA__DIRTY) {			/* Write-back dirty buffer if needed */

-			if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)

-				ABORT(fp->fs, FR_DISK_ERR);

-			fp->flag &= ~FA__DIRTY;

-		}

-#endif

-		if (disk_read(fp->fs->drive, fp->buf, nsect, 1) != RES_OK)

-			ABORT(fp->fs, FR_DISK_ERR);

-#endif

-		fp->dsect = nsect;

-	}

-#if !_FS_READONLY

-	if (fp->fptr > fp->fsize) {			/* Set changed flag if the file size is extended */

-		fp->fsize = fp->fptr;

-		fp->flag |= FA__WRITTEN;

-	}

-#endif

-

-	LEAVE_FF(fp->fs, res);

-}

-

-

-

-

-#if _FS_MINIMIZE <= 1

-/*-----------------------------------------------------------------------*/

-/* Create a Directroy Object                                             */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_opendir (

-	DIR *dj,			/* Pointer to directory object to create */

-	const XCHAR *path	/* Pointer to the directory path */

-)

-{

-	FRESULT res;

-	NAMEBUF(sfn, lfn);

-	BYTE *dir;

-

-

-	res = chk_mounted(&path, &dj->fs, 0);

-	if (res == FR_OK) {

-		INITBUF((*dj), sfn, lfn);

-		res = follow_path(dj, path);			/* Follow the path to the directory */

-		if (res == FR_OK) {						/* Follow completed */

-			dir = dj->dir;

-			if (dir) {							/* It is not the root dir */

-				if (dir[DIR_Attr] & AM_DIR) {	/* The object is a directory */

-					dj->sclust = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);

-				} else {						/* The object is not a directory */

-					res = FR_NO_PATH;

-				}

-			}

-			if (res == FR_OK) {

-				dj->id = dj->fs->id;

-				res = dir_seek(dj, 0);			/* Rewind dir */

-			}

-		}

-		if (res == FR_NO_FILE) res = FR_NO_PATH;

-	}

-

-	LEAVE_FF(dj->fs, res);

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Read Directory Entry in Sequense                                      */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_readdir (

-	DIR *dj,			/* Pointer to the open directory object */

-	FILINFO *fno		/* Pointer to file information to return */

-)

-{

-	FRESULT res;

-	NAMEBUF(sfn, lfn);

-

-

-	res = validate(dj->fs, dj->id);			/* Check validity of the object */

-	if (res == FR_OK) {

-		INITBUF((*dj), sfn, lfn);

-		if (!fno) {

-			res = dir_seek(dj, 0);

-		} else {

-			res = dir_read(dj);

-			if (res == FR_NO_FILE) {

-				dj->sect = 0;

-				res = FR_OK;

-			}

-			if (res == FR_OK) {				/* A valid entry is found */

-				get_fileinfo(dj, fno);		/* Get the object information */

-				res = dir_next(dj, FALSE);	/* Increment index for next */

-				if (res == FR_NO_FILE) {

-					dj->sect = 0;

-					res = FR_OK;

-				}

-			}

-		}

-	}

-

-	LEAVE_FF(dj->fs, res);

-}

-

-

-

-#if _FS_MINIMIZE == 0

-/*-----------------------------------------------------------------------*/

-/* Get File Status                                                       */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_stat (

-	const XCHAR *path,	/* Pointer to the file path */

-	FILINFO *fno		/* Pointer to file information to return */

-)

-{

-	FRESULT res;

-	DIR dj;

-	NAMEBUF(sfn, lfn);

-

-

-	res = chk_mounted(&path, &dj.fs, 0);

-	if (res == FR_OK) {

-		INITBUF(dj, sfn, lfn);

-		res = follow_path(&dj, path);	/* Follow the file path */

-		if (res == FR_OK) {				/* Follwo completed */

-			if (dj.dir)	/* Found an object */

-				get_fileinfo(&dj, fno);

-			else		/* It is root dir */

-				res = FR_INVALID_NAME;

-		}

-	}

-

-	LEAVE_FF(dj.fs, res);

-}

-

-

-

-#if !_FS_READONLY

-/*-----------------------------------------------------------------------*/

-/* Get Number of Free Clusters                                           */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_getfree (

-	const XCHAR *path,	/* Pointer to the logical drive number (root dir) */

-	DWORD *nclst,		/* Pointer to the variable to return number of free clusters */

-	FATFS **fatfs		/* Pointer to pointer to corresponding file system object to return */

-)

-{

-	FRESULT res;

-	DWORD n, clst, sect, stat;

-	UINT i;

-	BYTE fat, *p;

-

-

-	/* Get drive number */

-	res = chk_mounted(&path, fatfs, 0);

-	if (res != FR_OK) LEAVE_FF(*fatfs, res);

-

-	/* If number of free cluster is valid, return it without cluster scan. */

-	if ((*fatfs)->free_clust <= (*fatfs)->max_clust - 2) {

-		*nclst = (*fatfs)->free_clust;

-		LEAVE_FF(*fatfs, FR_OK);

-	}

-

-	/* Get number of free clusters */

-	fat = (*fatfs)->fs_type;

-	n = 0;

-	if (fat == FS_FAT12) {

-		clst = 2;

-		do {

-			stat = get_fat(*fatfs, clst);

-			if (stat == 0xFFFFFFFF) LEAVE_FF(*fatfs, FR_DISK_ERR);

-			if (stat == 1) LEAVE_FF(*fatfs, FR_INT_ERR);

-			if (stat == 0) n++;

-		} while (++clst < (*fatfs)->max_clust);

-	} else {

-		clst = (*fatfs)->max_clust;

-		sect = (*fatfs)->fatbase;

-		i = 0; p = 0;

-		do {

-			if (!i) {

-				res = move_window(*fatfs, sect++);

-				if (res != FR_OK)

-					LEAVE_FF(*fatfs, res);

-				p = (*fatfs)->win;

-				i = SS(*fatfs);

-			}

-			if (fat == FS_FAT16) {

-				if (LD_WORD(p) == 0) n++;

-				p += 2; i -= 2;

-			} else {

-				if ((LD_DWORD(p) & 0x0FFFFFFF) == 0) n++;

-				p += 4; i -= 4;

-			}

-		} while (--clst);

-	}

-	(*fatfs)->free_clust = n;

-	if (fat == FS_FAT32) (*fatfs)->fsi_flag = 1;

-	*nclst = n;

-

-	LEAVE_FF(*fatfs, FR_OK);

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Truncate File                                                         */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_truncate (

-	FIL *fp		/* Pointer to the file object */

-)

-{

-	FRESULT res;

-	DWORD ncl;

-

-

-	res = validate(fp->fs, fp->id);		/* Check validity of the object */

-	if (res != FR_OK) LEAVE_FF(fp->fs, res);

-	if (fp->flag & FA__ERROR)			/* Check abort flag */

-		LEAVE_FF(fp->fs, FR_INT_ERR);

-	if (!(fp->flag & FA_WRITE))			/* Check access mode */

-		LEAVE_FF(fp->fs, FR_DENIED);

-

-	if (fp->fsize > fp->fptr) {

-		fp->fsize = fp->fptr;	/* Set file size to current R/W point */

-		fp->flag |= FA__WRITTEN;

-		if (fp->fptr == 0) {	/* When set file size to zero, remove entire cluster chain */

-			res = remove_chain(fp->fs, fp->org_clust);

-			fp->org_clust = 0;

-		} else {				/* When truncate a part of the file, remove remaining clusters */

-			ncl = get_fat(fp->fs, fp->curr_clust);

-			res = FR_OK;

-			if (ncl == 0xFFFFFFFF) res = FR_DISK_ERR;

-			if (ncl == 1) res = FR_INT_ERR;

-			if (res == FR_OK && ncl < fp->fs->max_clust) {

-				res = put_fat(fp->fs, fp->curr_clust, 0x0FFFFFFF);

-				if (res == FR_OK) res = remove_chain(fp->fs, ncl);

-			}

-		}

-	}

-	if (res != FR_OK) fp->flag |= FA__ERROR;

-

-	LEAVE_FF(fp->fs, res);

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Delete a File or Directory                                            */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_unlink (

-	const XCHAR *path		/* Pointer to the file or directory path */

-)

-{

-	FRESULT res;

-	DIR dj, sdj;

-	NAMEBUF(sfn, lfn);

-	BYTE *dir;

-	DWORD dclst;

-

-

-	res = chk_mounted(&path, &dj.fs, 1);

-	if (res != FR_OK) LEAVE_FF(dj.fs, res);

-

-	INITBUF(dj, sfn, lfn);

-	res = follow_path(&dj, path);			/* Follow the file path */

-	if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))

-		res = FR_INVALID_NAME;

-	if (res != FR_OK) LEAVE_FF(dj.fs, res); /* Follow failed */

-

-	dir = dj.dir;

-	if (!dir)								/* Is it the root directory? */

-		LEAVE_FF(dj.fs, FR_INVALID_NAME);

-	if (dir[DIR_Attr] & AM_RDO)				/* Is it a R/O object? */

-		LEAVE_FF(dj.fs, FR_DENIED);

-	dclst = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);

-

-	if (dir[DIR_Attr] & AM_DIR) {			/* It is a sub-directory */

-		if (dclst < 2) LEAVE_FF(dj.fs, FR_INT_ERR);

-		mem_cpy(&sdj, &dj, sizeof(DIR));	/* Check if the sub-dir is empty or not */

-		sdj.sclust = dclst;

-		res = dir_seek(&sdj, 2);

-		if (res != FR_OK) LEAVE_FF(dj.fs, res);

-		res = dir_read(&sdj);

-		if (res == FR_OK) res = FR_DENIED;	/* Not empty sub-dir */

-		if (res != FR_NO_FILE) LEAVE_FF(dj.fs, res);

-	}

-

-	res = dir_remove(&dj);					/* Remove directory entry */

-	if (res == FR_OK) {

-		if (dclst)

-			res = remove_chain(dj.fs, dclst);	/* Remove the cluster chain */

-		if (res == FR_OK) res = sync(dj.fs);

-	}

-

-	LEAVE_FF(dj.fs, res);

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Create a Directory                                                    */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_mkdir (

-	const XCHAR *path		/* Pointer to the directory path */

-)

-{

-	FRESULT res;

-	DIR dj;

-	NAMEBUF(sfn, lfn);

-	BYTE *dir, n;

-	DWORD dsect, dclst, pclst, tim;

-

-

-	res = chk_mounted(&path, &dj.fs, 1);

-	if (res != FR_OK) LEAVE_FF(dj.fs, res);

-

-	INITBUF(dj, sfn, lfn);

-	res = follow_path(&dj, path);			/* Follow the file path */

-	if (res == FR_OK) res = FR_EXIST;		/* Any file or directory is already existing */

-	if (_FS_RPATH && res == FR_NO_FILE && (dj.fn[NS] & NS_DOT))

-		res = FR_INVALID_NAME;

-	if (res != FR_NO_FILE)					/* Any error occured */

-		LEAVE_FF(dj.fs, res);

-

-	dclst = create_chain(dj.fs, 0);			/* Allocate a new cluster for new directory table */

-	res = FR_OK;

-	if (dclst == 0) res = FR_DENIED;

-	if (dclst == 1) res = FR_INT_ERR;

-	if (dclst == 0xFFFFFFFF) res = FR_DISK_ERR;

-	if (res == FR_OK)

-		res = move_window(dj.fs, 0);

-	if (res != FR_OK) LEAVE_FF(dj.fs, res);

-	dsect = clust2sect(dj.fs, dclst);

-

-	dir = dj.fs->win;						/* Initialize the new directory table */

-	mem_set(dir, 0, SS(dj.fs));

-	mem_set(dir+DIR_Name, ' ', 8+3);		/* Create "." entry */

-	dir[DIR_Name] = '.';

-	dir[DIR_Attr] = AM_DIR;

-	tim = get_fattime();

-	ST_DWORD(dir+DIR_WrtTime, tim);

-	ST_WORD(dir+DIR_FstClusLO, dclst);

-	ST_WORD(dir+DIR_FstClusHI, dclst >> 16);

-	mem_cpy(dir+32, dir, 32); 			/* Create ".." entry */

-	dir[33] = '.';

-	pclst = dj.sclust;

-	if (dj.fs->fs_type == FS_FAT32 && pclst == dj.fs->dirbase)

-		pclst = 0;

-	ST_WORD(dir+32+DIR_FstClusLO, pclst);

-	ST_WORD(dir+32+DIR_FstClusHI, pclst >> 16);

-	for (n = 0; n < dj.fs->csize; n++) {	/* Write dot entries and clear left sectors */

-		dj.fs->winsect = dsect++;

-		dj.fs->wflag = 1;

-		res = move_window(dj.fs, 0);

-		if (res) LEAVE_FF(dj.fs, res);

-		mem_set(dir, 0, SS(dj.fs));

-	}

-

-	res = dir_register(&dj);

-	if (res != FR_OK) {

-		remove_chain(dj.fs, dclst);

-	} else {

-		dir = dj.dir;

-		dir[DIR_Attr] = AM_DIR;					/* Attribute */

-		ST_DWORD(dir+DIR_WrtTime, tim);			/* Crated time */

-		ST_WORD(dir+DIR_FstClusLO, dclst);		/* Table start cluster */

-		ST_WORD(dir+DIR_FstClusHI, dclst >> 16);

-		dj.fs->wflag = 1;

-		res = sync(dj.fs);

-	}

-

-	LEAVE_FF(dj.fs, res);

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Change File Attribute                                                 */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_chmod (

-	const XCHAR *path,	/* Pointer to the file path */

-	BYTE value,			/* Attribute bits */

-	BYTE mask			/* Attribute mask to change */

-)

-{

-	FRESULT res;

-	DIR dj;

-	NAMEBUF(sfn, lfn);

-	BYTE *dir;

-

-

-	res = chk_mounted(&path, &dj.fs, 1);

-	if (res == FR_OK) {

-		INITBUF(dj, sfn, lfn);

-		res = follow_path(&dj, path);		/* Follow the file path */

-		if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))

-			res = FR_INVALID_NAME;

-		if (res == FR_OK) {

-			dir = dj.dir;

-			if (!dir) {						/* Is it a root directory? */

-				res = FR_INVALID_NAME;

-			} else {						/* File or sub directory */

-				mask &= AM_RDO|AM_HID|AM_SYS|AM_ARC;	/* Valid attribute mask */

-				dir[DIR_Attr] = (value & mask) | (dir[DIR_Attr] & (BYTE)~mask);	/* Apply attribute change */

-				dj.fs->wflag = 1;

-				res = sync(dj.fs);

-			}

-		}

-	}

-

-	LEAVE_FF(dj.fs, res);

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Change Timestamp                                                      */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_utime (

-	const XCHAR *path,	/* Pointer to the file/directory name */

-	const FILINFO *fno	/* Pointer to the timestamp to be set */

-)

-{

-	FRESULT res;

-	DIR dj;

-	NAMEBUF(sfn, lfn);

-	BYTE *dir;

-

-

-	res = chk_mounted(&path, &dj.fs, 1);

-	if (res == FR_OK) {

-		INITBUF(dj, sfn, lfn);

-		res = follow_path(&dj, path);	/* Follow the file path */

-		if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))

-			res = FR_INVALID_NAME;

-		if (res == FR_OK) {

-			dir = dj.dir;

-			if (!dir) {				/* Root directory */

-				res = FR_INVALID_NAME;

-			} else {				/* File or sub-directory */

-				ST_WORD(dir+DIR_WrtTime, fno->ftime);

-				ST_WORD(dir+DIR_WrtDate, fno->fdate);

-				dj.fs->wflag = 1;

-				res = sync(dj.fs);

-			}

-		}

-	}

-

-	LEAVE_FF(dj.fs, res);

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Rename File/Directory                                                 */

-/*-----------------------------------------------------------------------*/

-

-FRESULT f_rename (

-	const XCHAR *path_old,	/* Pointer to the old name */

-	const XCHAR *path_new	/* Pointer to the new name */

-)

-{

-	FRESULT res;

-	DIR dj_old, dj_new;

-	NAMEBUF(sfn, lfn);

-	BYTE buf[21], *dir;

-	DWORD dw;

-

-

-	INITBUF(dj_old, sfn, lfn);

-	res = chk_mounted(&path_old, &dj_old.fs, 1);

-	if (res == FR_OK) {

-		dj_new.fs = dj_old.fs;

-		res = follow_path(&dj_old, path_old);	/* Check old object */

-		if (_FS_RPATH && res == FR_OK && (dj_old.fn[NS] & NS_DOT))

-			res = FR_INVALID_NAME;

-	}

-	if (res != FR_OK) LEAVE_FF(dj_old.fs, res);	/* The old object is not found */

-

-	if (!dj_old.dir) LEAVE_FF(dj_old.fs, FR_NO_FILE);	/* Is root dir? */

-	mem_cpy(buf, dj_old.dir+DIR_Attr, 21);		/* Save the object information */

-

-	mem_cpy(&dj_new, &dj_old, sizeof(DIR));

-	res = follow_path(&dj_new, path_new);		/* Check new object */

-	if (res == FR_OK) res = FR_EXIST;			/* The new object name is already existing */

-	if (res == FR_NO_FILE) { 					/* Is it a valid path and no name collision? */

-		res = dir_register(&dj_new);			/* Register the new object */

-		if (res == FR_OK) {

-			dir = dj_new.dir;					/* Copy object information into new entry */

-			mem_cpy(dir+13, buf+2, 19);

-			dir[DIR_Attr] = buf[0] | AM_ARC;

-			dj_old.fs->wflag = 1;

-			if (dir[DIR_Attr] & AM_DIR) {		/* Update .. entry in the directory if needed */

-				dw = clust2sect(dj_new.fs, (DWORD)LD_WORD(dir+DIR_FstClusHI) | LD_WORD(dir+DIR_FstClusLO));

-				if (!dw) {

-					res = FR_INT_ERR;

-				} else {

-					res = move_window(dj_new.fs, dw);

-					dir = dj_new.fs->win+32;

-					if (res == FR_OK && dir[1] == '.') {

-						dw = (dj_new.fs->fs_type == FS_FAT32 && dj_new.sclust == dj_new.fs->dirbase) ? 0 : dj_new.sclust;

-						ST_WORD(dir+DIR_FstClusLO, dw);

-						ST_WORD(dir+DIR_FstClusHI, dw >> 16);

-						dj_new.fs->wflag = 1;

-					}

-				}

-			}

-			if (res == FR_OK) {

-				res = dir_remove(&dj_old);			/* Remove old entry */

-				if (res == FR_OK)

-					res = sync(dj_old.fs);

-			}

-		}

-	}

-

-	LEAVE_FF(dj_old.fs, res);

-}

-

-#endif /* !_FS_READONLY */

-#endif /* _FS_MINIMIZE == 0 */

-#endif /* _FS_MINIMIZE <= 1 */

-#endif /* _FS_MINIMIZE <= 2 */

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Forward data to the stream directly (Available on only _FS_TINY cfg)  */

-/*-----------------------------------------------------------------------*/

-#if _USE_FORWARD && _FS_TINY

-

-FRESULT f_forward (

-	FIL *fp, 						/* Pointer to the file object */

-	UINT (*func)(const BYTE*,UINT),	/* Pointer to the streaming function */

-	UINT btr,						/* Number of bytes to forward */

-	UINT *bf						/* Pointer to number of bytes forwarded */

-)

-{

-	FRESULT res;

-	DWORD remain, clst, sect;

-	UINT rcnt;

-

-

-	*bf = 0;

-

-	res = validate(fp->fs, fp->id);					/* Check validity of the object */

-	if (res != FR_OK) LEAVE_FF(fp->fs, res);

-	if (fp->flag & FA__ERROR)						/* Check error flag */

-		LEAVE_FF(fp->fs, FR_INT_ERR);

-	if (!(fp->flag & FA_READ))						/* Check access mode */

-		LEAVE_FF(fp->fs, FR_DENIED);

-

-	remain = fp->fsize - fp->fptr;

-	if (btr > remain) btr = (UINT)remain;			/* Truncate btr by remaining bytes */

-

-	for ( ;  btr && (*func)(NULL, 0);				/* Repeat until all data transferred or stream becomes busy */

-		fp->fptr += rcnt, *bf += rcnt, btr -= rcnt) {

-		if ((fp->fptr % SS(fp->fs)) == 0) {			/* On the sector boundary? */

-			if (fp->csect >= fp->fs->csize) {		/* On the cluster boundary? */

-				clst = (fp->fptr == 0) ?			/* On the top of the file? */

-					fp->org_clust : get_fat(fp->fs, fp->curr_clust);

-				if (clst <= 1) ABORT(fp->fs, FR_INT_ERR);

-				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);

-				fp->curr_clust = clst;				/* Update current cluster */

-				fp->csect = 0;						/* Reset sector address in the cluster */

-			}

-			fp->csect++;							/* Next sector address in the cluster */

-		}

-		sect = clust2sect(fp->fs, fp->curr_clust);	/* Get current data sector */

-		if (!sect) ABORT(fp->fs, FR_INT_ERR);

-		sect += fp->csect - 1;

-		if (move_window(fp->fs, sect))				/* Move sector window */

-			ABORT(fp->fs, FR_DISK_ERR);

-		fp->dsect = sect;

-		rcnt = SS(fp->fs) - (WORD)(fp->fptr % SS(fp->fs));	/* Forward data from sector window */

-		if (rcnt > btr) rcnt = btr;

-		rcnt = (*func)(&fp->fs->win[(WORD)fp->fptr % SS(fp->fs)], rcnt);

-		if (!rcnt) ABORT(fp->fs, FR_INT_ERR);

-	}

-

-	LEAVE_FF(fp->fs, FR_OK);

-}

-#endif /* _USE_FORWARD */

-

-

-

-#if _USE_MKFS && !_FS_READONLY

-/*-----------------------------------------------------------------------*/

-/* Create File System on the Drive                                       */

-/*-----------------------------------------------------------------------*/

-#define N_ROOTDIR	512			/* Multiple of 32 and <= 2048 */

-#define N_FATS		1			/* 1 or 2 */

-#define MAX_SECTOR	131072000UL	/* Maximum partition size */

-#define MIN_SECTOR	2000UL		/* Minimum partition size */

-

-

-FRESULT f_mkfs (

-	BYTE drv,			/* Logical drive number */

-	BYTE partition,		/* Partitioning rule 0:FDISK, 1:SFD */

-	WORD allocsize		/* Allocation unit size [bytes] */

-)

-{

-	static const DWORD sstbl[] = { 2048000, 1024000, 512000, 256000, 128000, 64000, 32000, 16000, 8000, 4000,   0 };

-	static const WORD cstbl[] =  {   32768,   16384,   8192,   4096,   2048, 16384,  8192,  4096, 2048, 1024, 512 };

-	BYTE fmt, m, *tbl;

-	DWORD b_part, b_fat, b_dir, b_data;		/* Area offset (LBA) */

-	DWORD n_part, n_rsv, n_fat, n_dir;		/* Area size */

-	DWORD n_clst, d, n;

-	WORD as;

-	FATFS *fs;

-	DSTATUS stat;

-

-

-	/* Check validity of the parameters */

-	if (drv >= _DRIVES) return FR_INVALID_DRIVE;

-	if (partition >= 2) return FR_MKFS_ABORTED;

-

-	/* Check mounted drive and clear work area */

-	fs = FatFs[drv];

-	if (!fs) return FR_NOT_ENABLED;

-	fs->fs_type = 0;

-	drv = LD2PD(drv);

-

-	/* Get disk statics */

-	stat = disk_initialize(drv);

-	if (stat & STA_NOINIT) return FR_NOT_READY;

-	if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;

-#if _MAX_SS != 512						/* Get disk sector size */

-	if (disk_ioctl(drv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK

-		|| SS(fs) > _MAX_SS)

-		return FR_MKFS_ABORTED;

-#endif

-	if (disk_ioctl(drv, GET_SECTOR_COUNT, &n_part) != RES_OK || n_part < MIN_SECTOR)

-		return FR_MKFS_ABORTED;

-	if (n_part > MAX_SECTOR) n_part = MAX_SECTOR;

-	b_part = (!partition) ? 63 : 0;		/* Boot sector */

-	n_part -= b_part;

-	for (d = 512; d <= 32768U && d != allocsize; d <<= 1) ;	/* Check validity of the allocation unit size */

-	if (d != allocsize) allocsize = 0;

-	if (!allocsize) {					/* Auto selection of cluster size */

-		d = n_part;

-		for (as = SS(fs); as > 512U; as >>= 1) d >>= 1;

-		for (n = 0; d < sstbl[n]; n++) ;

-		allocsize = cstbl[n];

-	}

-	if (allocsize < SS(fs)) allocsize = SS(fs);

-

-	allocsize /= SS(fs);		/* Number of sectors per cluster */

-

-	/* Pre-compute number of clusters and FAT type */

-	n_clst = n_part / allocsize;

-	fmt = FS_FAT12;

-	if (n_clst >= 0xFF5) fmt = FS_FAT16;

-	if (n_clst >= 0xFFF5) fmt = FS_FAT32;

-

-	/* Determine offset and size of FAT structure */

-	switch (fmt) {

-	case FS_FAT12:

-		n_fat = ((n_clst * 3 + 1) / 2 + 3 + SS(fs) - 1) / SS(fs);

-		n_rsv = 1 + partition;

-		n_dir = N_ROOTDIR * 32 / SS(fs);

-		break;

-	case FS_FAT16:

-		n_fat = ((n_clst * 2) + 4 + SS(fs) - 1) / SS(fs);

-		n_rsv = 1 + partition;

-		n_dir = N_ROOTDIR * 32 / SS(fs);

-		break;

-	default:

-		n_fat = ((n_clst * 4) + 8 + SS(fs) - 1) / SS(fs);

-		n_rsv = 33 - partition;

-		n_dir = 0;

-	}

-	b_fat = b_part + n_rsv;			/* FATs start sector */

-	b_dir = b_fat + n_fat * N_FATS;	/* Directory start sector */

-	b_data = b_dir + n_dir;			/* Data start sector */

-

-	/* Align data start sector to erase block boundary (for flash memory media) */

-	if (disk_ioctl(drv, GET_BLOCK_SIZE, &n) != RES_OK) return FR_MKFS_ABORTED;

-	n = (b_data + n - 1) & ~(n - 1);

-	n_fat += (n - b_data) / N_FATS;

-	/* b_dir and b_data are no longer used below */

-

-	/* Determine number of cluster and final check of validity of the FAT type */

-	n_clst = (n_part - n_rsv - n_fat * N_FATS - n_dir) / allocsize;

-	if (   (fmt == FS_FAT16 && n_clst < 0xFF5)

-		|| (fmt == FS_FAT32 && n_clst < 0xFFF5))

-		return FR_MKFS_ABORTED;

-

-	/* Create partition table if needed */

-	if (!partition) {

-		DWORD n_disk = b_part + n_part;

-

-		mem_set(fs->win, 0, SS(fs));

-		tbl = fs->win+MBR_Table;

-		ST_DWORD(tbl, 0x00010180);		/* Partition start in CHS */

-		if (n_disk < 63UL * 255 * 1024) {	/* Partition end in CHS */

-			n_disk = n_disk / 63 / 255;

-			tbl[7] = (BYTE)n_disk;

-			tbl[6] = (BYTE)((n_disk >> 2) | 63);

-		} else {

-			ST_WORD(&tbl[6], 0xFFFF);

-		}

-		tbl[5] = 254;

-		if (fmt != FS_FAT32)			/* System ID */

-			tbl[4] = (n_part < 0x10000) ? 0x04 : 0x06;

-		else

-			tbl[4] = 0x0c;

-		ST_DWORD(tbl+8, 63);			/* Partition start in LBA */

-		ST_DWORD(tbl+12, n_part);		/* Partition size in LBA */

-		ST_WORD(tbl+64, 0xAA55);		/* Signature */

-		if (disk_write(drv, fs->win, 0, 1) != RES_OK)

-			return FR_DISK_ERR;

-		partition = 0xF8;

-	} else {

-		partition = 0xF0;

-	}

-

-	/* Create boot record */

-	tbl = fs->win;								/* Clear buffer */

-	mem_set(tbl, 0, SS(fs));

-	ST_DWORD(tbl+BS_jmpBoot, 0x90FEEB);			/* Boot code (jmp $, nop) */

-	ST_WORD(tbl+BPB_BytsPerSec, SS(fs));		/* Sector size */

-	tbl[BPB_SecPerClus] = (BYTE)allocsize;		/* Sectors per cluster */

-	ST_WORD(tbl+BPB_RsvdSecCnt, n_rsv);			/* Reserved sectors */

-	tbl[BPB_NumFATs] = N_FATS;					/* Number of FATs */

-	ST_WORD(tbl+BPB_RootEntCnt, SS(fs) / 32 * n_dir); /* Number of rootdir entries */

-	if (n_part < 0x10000) {						/* Number of total sectors */

-		ST_WORD(tbl+BPB_TotSec16, n_part);

-	} else {

-		ST_DWORD(tbl+BPB_TotSec32, n_part);

-	}

-	tbl[BPB_Media] = partition;					/* Media descripter */

-	ST_WORD(tbl+BPB_SecPerTrk, 63);				/* Number of sectors per track */

-	ST_WORD(tbl+BPB_NumHeads, 255);				/* Number of heads */

-	ST_DWORD(tbl+BPB_HiddSec, b_part);			/* Hidden sectors */

-	n = get_fattime();							/* Use current time as a VSN */

-	if (fmt != FS_FAT32) {

-		ST_DWORD(tbl+BS_VolID, n);				/* Volume serial number */

-		ST_WORD(tbl+BPB_FATSz16, n_fat);		/* Number of secters per FAT */

-		tbl[BS_DrvNum] = 0x80;					/* Drive number */

-		tbl[BS_BootSig] = 0x29;					/* Extended boot signature */

-		mem_cpy(tbl+BS_VolLab, "NO NAME    FAT     ", 19);	/* Volume lavel, FAT signature */

-	} else {

-		ST_DWORD(tbl+BS_VolID32, n);			/* Volume serial number */

-		ST_DWORD(tbl+BPB_FATSz32, n_fat);		/* Number of secters per FAT */

-		ST_DWORD(tbl+BPB_RootClus, 2);			/* Root directory cluster (2) */

-		ST_WORD(tbl+BPB_FSInfo, 1);				/* FSInfo record offset (bs+1) */

-		ST_WORD(tbl+BPB_BkBootSec, 6);			/* Backup boot record offset (bs+6) */

-		tbl[BS_DrvNum32] = 0x80;				/* Drive number */

-		tbl[BS_BootSig32] = 0x29;				/* Extended boot signature */

-		mem_cpy(tbl+BS_VolLab32, "NO NAME    FAT32   ", 19);	/* Volume lavel, FAT signature */

-	}

-	ST_WORD(tbl+BS_55AA, 0xAA55);				/* Signature */

-	if (SS(fs) > 512U) {

-		ST_WORD(tbl+SS(fs)-2, 0xAA55);

-	}

-	if (disk_write(drv, tbl, b_part+0, 1) != RES_OK)

-		return FR_DISK_ERR;

-	if (fmt == FS_FAT32)

-		disk_write(drv, tbl, b_part+6, 1);

-

-	/* Initialize FAT area */

-	for (m = 0; m < N_FATS; m++) {

-		mem_set(tbl, 0, SS(fs));		/* 1st sector of the FAT  */

-		if (fmt != FS_FAT32) {

-			n = (fmt == FS_FAT12) ? 0x00FFFF00 : 0xFFFFFF00;

-			n |= partition;

-			ST_DWORD(tbl, n);				/* Reserve cluster #0-1 (FAT12/16) */

-		} else {

-			ST_DWORD(tbl+0, 0xFFFFFFF8);	/* Reserve cluster #0-1 (FAT32) */

-			ST_DWORD(tbl+4, 0xFFFFFFFF);

-			ST_DWORD(tbl+8, 0x0FFFFFFF);	/* Reserve cluster #2 for root dir */

-		}

-		if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)

-			return FR_DISK_ERR;

-		mem_set(tbl, 0, SS(fs));		/* Following FAT entries are filled by zero */

-		for (n = 1; n < n_fat; n++) {

-			if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)

-				return FR_DISK_ERR;

-		}

-	}

-

-	/* Initialize Root directory */

-	m = (BYTE)((fmt == FS_FAT32) ? allocsize : n_dir);

-	do {

-		if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)

-			return FR_DISK_ERR;

-	} while (--m);

-

-	/* Create FSInfo record if needed */

-	if (fmt == FS_FAT32) {

-		ST_WORD(tbl+BS_55AA, 0xAA55);

-		ST_DWORD(tbl+FSI_LeadSig, 0x41615252);

-		ST_DWORD(tbl+FSI_StrucSig, 0x61417272);

-		ST_DWORD(tbl+FSI_Free_Count, n_clst - 1);

-		ST_DWORD(tbl+FSI_Nxt_Free, 0xFFFFFFFF);

-		disk_write(drv, tbl, b_part+1, 1);

-		disk_write(drv, tbl, b_part+7, 1);

-	}

-

-	return (disk_ioctl(drv, CTRL_SYNC, (void*)NULL) == RES_OK) ? FR_OK : FR_DISK_ERR;

-}

-

-#endif /* _USE_MKFS && !_FS_READONLY */

-

-

-

-

-#if _USE_STRFUNC

-/*-----------------------------------------------------------------------*/

-/* Get a string from the file                                            */

-/*-----------------------------------------------------------------------*/

-char* f_gets (

-	char* buff,	/* Pointer to the string buffer to read */

-	int len,	/* Size of string buffer */

-	FIL* fil	/* Pointer to the file object */

-)

-{

-	int i = 0;

-	char *p = buff;

-	UINT rc;

-

-

-	while (i < len - 1) {			/* Read bytes until buffer gets filled */

-		f_read(fil, p, 1, &rc);

-		if (rc != 1) break;			/* Break when no data to read */

-#if _USE_STRFUNC >= 2

-		if (*p == '\r') continue;	/* Strip '\r' */

-#endif

-		i++;

-		if (*p++ == '\n') break;	/* Break when reached end of line */

-	}

-	*p = 0;

-	return i ? buff : NULL;			/* When no data read (eof or error), return with error. */

-}

-

-

-

-#if !_FS_READONLY

-#include <stdarg.h>

-/*-----------------------------------------------------------------------*/

-/* Put a character to the file                                           */

-/*-----------------------------------------------------------------------*/

-int f_putc (

-	int chr,	/* A character to be output */

-	FIL* fil	/* Ponter to the file object */

-)

-{

-	UINT bw;

-	char c;

-

-

-#if _USE_STRFUNC >= 2

-	if (chr == '\n') f_putc ('\r', fil);	/* LF -> CRLF conversion */

-#endif

-	if (!fil) {	/* Special value may be used to switch the destination to any other device */

-	/*	put_console(chr);	*/

-		return chr;

-	}

-	c = (char)chr;

-	f_write(fil, &c, 1, &bw);	/* Write a byte to the file */

-	return bw ? chr : EOF;		/* Return the result */

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Put a string to the file                                              */

-/*-----------------------------------------------------------------------*/

-int f_puts (

-	const char* str,	/* Pointer to the string to be output */

-	FIL* fil			/* Pointer to the file object */

-)

-{

-	int n;

-

-

-	for (n = 0; *str; str++, n++) {

-		if (f_putc(*str, fil) == EOF) return EOF;

-	}

-	return n;

-}

-

-

-

-

-/*-----------------------------------------------------------------------*/

-/* Put a formatted string to the file                                    */

-/*-----------------------------------------------------------------------*/

-int f_printf (

-	FIL* fil,			/* Pointer to the file object */

-	const char* str,	/* Pointer to the format string */

-	...					/* Optional arguments... */

-)

-{

-	va_list arp;

-	UCHAR c, f, r;

-	ULONG val;

-	char s[16];

-	int i, w, res, cc;

-

-

-	va_start(arp, str);

-

-	for (cc = res = 0; cc != EOF; res += cc) {

-		c = *str++;

-		if (c == 0) break;			/* End of string */

-		if (c != '%') {				/* Non escape cahracter */

-			cc = f_putc(c, fil);

-			if (cc != EOF) cc = 1;

-			continue;

-		}

-		w = f = 0;

-		c = *str++;

-		if (c == '0') {				/* Flag: '0' padding */

-			f = 1; c = *str++;

-		}

-		while (c >= '0' && c <= '9') {	/* Precision */

-			w = w * 10 + (c - '0');

-			c = *str++;

-		}

-		if (c == 'l') {				/* Prefix: Size is long int */

-			f |= 2; c = *str++;

-		}

-		if (c == 's') {				/* Type is string */

-			cc = f_puts(va_arg(arp, char*), fil);

-			continue;

-		}

-		if (c == 'c') {				/* Type is character */

-			cc = f_putc(va_arg(arp, int), fil);

-			if (cc != EOF) cc = 1;

-			continue;

-		}

-		r = 0;

-		if (c == 'd') r = 10;		/* Type is signed decimal */

-		if (c == 'u') r = 10;		/* Type is unsigned decimal */

-		if (c == 'X') r = 16;		/* Type is unsigned hexdecimal */

-		if (r == 0) break;			/* Unknown type */

-		if (f & 2) {				/* Get the value */

-			val = (ULONG)va_arg(arp, long);

-		} else {

-			val = (c == 'd') ? (ULONG)(long)va_arg(arp, int) : (ULONG)va_arg(arp, unsigned int);

-		}

-		/* Put numeral string */

-		if (c == 'd') {

-			if (val & 0x80000000) {

-				val = 0 - val;

-				f |= 4;

-			}

-		}

-		i = sizeof(s) - 1; s[i] = 0;

-		do {

-			c = (UCHAR)(val % r + '0');

-			if (c > '9') c += 7;

-			s[--i] = c;

-			val /= r;

-		} while (i && val);

-		if (i && (f & 4)) s[--i] = '-';

-		w = sizeof(s) - 1 - w;

-		while (i && i > w) s[--i] = (f & 1) ? '0' : ' ';

-		cc = f_puts(&s[i], fil);

-	}

-

-	va_end(arp);

-	return (cc == EOF) ? cc : res;

-}

-

-#endif /* !_FS_READONLY */

-#endif /* _USE_STRFUNC */

+/*----------------------------------------------------------------------------/
+/  FatFs - FAT file system module  R0.07e                    (C)ChaN, 2010
+/-----------------------------------------------------------------------------/
+/ FatFs module is a generic FAT file system module for small embedded systems.
+/ This is a free software that opened for education, research and commercial
+/ developments under license policy of following trems.
+/
+/  Copyright (C) 2010, ChaN, all right reserved.
+/
+/ * The FatFs module is a free software and there is NO WARRANTY.
+/ * No restriction on use. You can use, modify and redistribute it for
+/   personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY.
+/ * Redistributions of source code must retain the above copyright notice.
+/
+/-----------------------------------------------------------------------------/
+/ Feb 26,'06 R0.00  Prototype.
+/
+/ Apr 29,'06 R0.01  First stable version.
+/
+/ Jun 01,'06 R0.02  Added FAT12 support.
+/                   Removed unbuffered mode.
+/                   Fixed a problem on small (<32M) patition.
+/ Jun 10,'06 R0.02a Added a configuration option (_FS_MINIMUM).
+/
+/ Sep 22,'06 R0.03  Added f_rename().
+/                   Changed option _FS_MINIMUM to _FS_MINIMIZE.
+/ Dec 11,'06 R0.03a Improved cluster scan algolithm to write files fast.
+/                   Fixed f_mkdir() creates incorrect directory on FAT32.
+/
+/ Feb 04,'07 R0.04  Supported multiple drive system.
+/                   Changed some interfaces for multiple drive system.
+/                   Changed f_mountdrv() to f_mount().
+/                   Added f_mkfs().
+/ Apr 01,'07 R0.04a Supported multiple partitions on a plysical drive.
+/                   Added a capability of extending file size to f_lseek().
+/                   Added minimization level 3.
+/                   Fixed an endian sensitive code in f_mkfs().
+/ May 05,'07 R0.04b Added a configuration option _USE_NTFLAG.
+/                   Added FSInfo support.
+/                   Fixed DBCS name can result FR_INVALID_NAME.
+/                   Fixed short seek (<= csize) collapses the file object.
+/
+/ Aug 25,'07 R0.05  Changed arguments of f_read(), f_write() and f_mkfs().
+/                   Fixed f_mkfs() on FAT32 creates incorrect FSInfo.
+/                   Fixed f_mkdir() on FAT32 creates incorrect directory.
+/ Feb 03,'08 R0.05a Added f_truncate() and f_utime().
+/                   Fixed off by one error at FAT sub-type determination.
+/                   Fixed btr in f_read() can be mistruncated.
+/                   Fixed cached sector is not flushed when create and close
+/                   without write.
+/
+/ Apr 01,'08 R0.06  Added fputc(), fputs(), fprintf() and fgets().
+/                   Improved performance of f_lseek() on moving to the same
+/                   or following cluster.
+/
+/ Apr 01,'09 R0.07  Merged Tiny-FatFs as a buffer configuration option.
+/                   Added long file name support.
+/                   Added multiple code page support.
+/                   Added re-entrancy for multitask operation.
+/                   Added auto cluster size selection to f_mkfs().
+/                   Added rewind option to f_readdir().
+/                   Changed result code of critical errors.
+/                   Renamed string functions to avoid name collision.
+/ Apr 14,'09 R0.07a Separated out OS dependent code on reentrant cfg.
+/                   Added multiple sector size support.
+/ Jun 21,'09 R0.07c Fixed f_unlink() can return FR_OK on error.
+/                   Fixed wrong cache control in f_lseek().
+/                   Added relative path feature.
+/                   Added f_chdir() and f_chdrive().
+/                   Added proper case conversion to extended char.
+/ Nov 03,'09 R0.07e Separated out configuration options from ff.h to ffconf.h.
+/                   Fixed f_unlink() fails to remove a sub-dir on _FS_RPATH.
+/                   Fixed name matching error on the 13 char boundary.
+/                   Added a configuration option, _LFN_UNICODE.
+/                   Changed f_readdir() to return the SFN with always upper
+/                   case on non-LFN cfg.
+/---------------------------------------------------------------------------*/
+
+#include "ff.h"			/* FatFs configurations and declarations */
+#include "diskio.h"		/* Declarations of low level disk I/O functions */
+
+/*--------------------------------------------------------------------------
+
+   Module Private Definitions
+
+---------------------------------------------------------------------------*/
+
+#if _FATFS != 0x007E
+#error Wrong include file (ff.h).
+#endif
+
+#if _FS_REENTRANT
+#if _USE_LFN == 1
+#error Static LFN work area must not be used in re-entrant configuration.
+#endif
+#define	ENTER_FF(fs)		{ if (!lock_fs(fs)) return FR_TIMEOUT; }
+#define	LEAVE_FF(fs, res)	{ unlock_fs(fs, res); return res; }
+
+#else
+#define	ENTER_FF(fs)
+#define LEAVE_FF(fs, res)	return res
+
+#endif
+
+#define	ABORT(fs, res)		{ fp->flag |= FA__ERROR; LEAVE_FF(fs, res); }
+
+#ifndef NULL
+#define	NULL	0
+#endif
+
+/* Name status flags */
+#define NS			11		/* Offset of name status byte */
+#define NS_LOSS		0x01	/* Out of 8.3 format */
+#define NS_LFN		0x02	/* Force to create LFN entry */
+#define NS_LAST		0x04	/* Last segment */
+#define NS_BODY		0x08	/* Lower case flag (body) */
+#define NS_EXT		0x10	/* Lower case flag (ext) */
+#define NS_DOT		0x20	/* Dot entry */
+
+
+
+
+/*--------------------------------------------------------------------------
+
+   Private Work Area
+
+---------------------------------------------------------------------------*/
+
+#if _DRIVES < 1 || _DRIVES > 9
+#error Number of drives must be 1-9.
+#endif
+static
+FATFS *FatFs[_DRIVES];	/* Pointer to the file system objects (logical drives) */
+
+static
+WORD Fsid;				/* File system mount ID */
+
+#if _FS_RPATH
+static
+BYTE Drive;				/* Current drive */
+#endif
+
+
+#if _USE_LFN == 1	/* LFN with static LFN working buffer */
+static
+WCHAR LfnBuf[_MAX_LFN + 1];
+#define	NAMEBUF(sp,lp)	BYTE sp[12]; WCHAR *lp = LfnBuf
+#define INITBUF(dj,sp,lp)	dj.fn = sp; dj.lfn = lp
+
+#elif _USE_LFN > 1	/* LFN with dynamic LFN working buffer */
+#define	NAMEBUF(sp,lp)	BYTE sp[12]; WCHAR lbuf[_MAX_LFN + 1], *lp = lbuf
+#define INITBUF(dj,sp,lp)	dj.fn = sp; dj.lfn = lp
+
+#else				/* No LFN */
+#define	NAMEBUF(sp,lp)	BYTE sp[12]
+#define INITBUF(dj,sp,lp)	dj.fn = sp
+
+#endif
+
+
+
+
+/*--------------------------------------------------------------------------
+
+   Module Private Functions
+
+---------------------------------------------------------------------------*/
+
+
+/*-----------------------------------------------------------------------*/
+/* String functions                                                      */
+/*-----------------------------------------------------------------------*/
+
+/* Copy memory to memory */
+static
+void mem_cpy (void* dst, const void* src, int cnt) {
+	char *d = (char*)dst;
+	const char *s = (const char *)src;
+	while (cnt--) *d++ = *s++;
+}
+
+/* Fill memory */
+static
+void mem_set (void* dst, int val, int cnt) {
+	char *d = (char*)dst;
+	while (cnt--) *d++ = (char)val;
+}
+
+/* Compare memory to memory */
+static
+int mem_cmp (const void* dst, const void* src, int cnt) {
+	const char *d = (const char *)dst, *s = (const char *)src;
+	int r = 0;
+	while (cnt-- && (r = *d++ - *s++) == 0) ;
+	return r;
+}
+
+/* Check if chr is contained in the string */
+static
+int chk_chr (const char* str, int chr) {
+	while (*str && *str != chr) str++;
+	return *str;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Request/Release grant to access the volume                            */
+/*-----------------------------------------------------------------------*/
+#if _FS_REENTRANT
+
+static
+BOOL lock_fs (
+	FATFS *fs		/* File system object */
+)
+{
+	return ff_req_grant(fs->sobj);
+}
+
+
+static
+void unlock_fs (
+	FATFS *fs,		/* File system object */
+	FRESULT res		/* Result code to be returned */
+)
+{
+	if (res != FR_NOT_ENABLED &&
+		res != FR_INVALID_DRIVE &&
+		res != FR_INVALID_OBJECT &&
+		res != FR_TIMEOUT) {
+		ff_rel_grant(fs->sobj);
+	}
+}
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Change window offset                                                  */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT move_window (
+	FATFS *fs,		/* File system object */
+	DWORD sector	/* Sector number to make apperance in the fs->win[] */
+)					/* Move to zero only writes back dirty window */
+{
+	DWORD wsect;
+
+
+	wsect = fs->winsect;
+	if (wsect != sector) {	/* Changed current window */
+#if !_FS_READONLY
+		if (fs->wflag) {	/* Write back dirty window if needed */
+			if (disk_write(fs->drive, fs->win, wsect, 1) != RES_OK)
+				return FR_DISK_ERR;
+			fs->wflag = 0;
+			if (wsect < (fs->fatbase + fs->sects_fat)) {	/* In FAT area */
+				BYTE nf;
+				for (nf = fs->n_fats; nf > 1; nf--) {	/* Refrect the change to all FAT copies */
+					wsect += fs->sects_fat;
+					disk_write(fs->drive, fs->win, wsect, 1);
+				}
+			}
+		}
+#endif
+		if (sector) {
+			if (disk_read(fs->drive, fs->win, sector, 1) != RES_OK)
+				return FR_DISK_ERR;
+			fs->winsect = sector;
+		}
+	}
+
+	return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Clean-up cached data                                                  */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+static
+FRESULT sync (	/* FR_OK: successful, FR_DISK_ERR: failed */
+	FATFS *fs	/* File system object */
+)
+{
+	FRESULT res;
+
+
+	res = move_window(fs, 0);
+	if (res == FR_OK) {
+		/* Update FSInfo sector if needed */
+		if (fs->fs_type == FS_FAT32 && fs->fsi_flag) {
+			fs->winsect = 0;
+			mem_set(fs->win, 0, 512);
+			ST_WORD(fs->win+BS_55AA, 0xAA55);
+			ST_DWORD(fs->win+FSI_LeadSig, 0x41615252);
+			ST_DWORD(fs->win+FSI_StrucSig, 0x61417272);
+			ST_DWORD(fs->win+FSI_Free_Count, fs->free_clust);
+			ST_DWORD(fs->win+FSI_Nxt_Free, fs->last_clust);
+			disk_write(fs->drive, fs->win, fs->fsi_sector, 1);
+			fs->fsi_flag = 0;
+		}
+		/* Make sure that no pending write process in the physical drive */
+		if (disk_ioctl(fs->drive, CTRL_SYNC, (void*)NULL) != RES_OK)
+			res = FR_DISK_ERR;
+	}
+
+	return res;
+}
+#endif
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT access - Read value of a FAT entry                                */
+/*-----------------------------------------------------------------------*/
+
+
+DWORD get_fat (	/* 0xFFFFFFFF:Disk error, 1:Interal error, Else:Cluster status */
+	FATFS *fs,	/* File system object */
+	DWORD clst	/* Cluster# to get the link information */
+)
+{
+	UINT wc, bc;
+	DWORD fsect;
+
+
+	if (clst < 2 || clst >= fs->max_clust)	/* Range check */
+		return 1;
+
+	fsect = fs->fatbase;
+	switch (fs->fs_type) {
+	case FS_FAT12 :
+		bc = clst; bc += bc / 2;
+		if (move_window(fs, fsect + (bc / SS(fs)))) break;
+		wc = fs->win[bc & (SS(fs) - 1)]; bc++;
+		if (move_window(fs, fsect + (bc / SS(fs)))) break;
+		wc |= (WORD)fs->win[bc & (SS(fs) - 1)] << 8;
+		return (clst & 1) ? (wc >> 4) : (wc & 0xFFF);
+
+	case FS_FAT16 :
+		if (move_window(fs, fsect + (clst / (SS(fs) / 2)))) break;
+		return LD_WORD(&fs->win[((WORD)clst * 2) & (SS(fs) - 1)]);
+
+	case FS_FAT32 :
+		if (move_window(fs, fsect + (clst / (SS(fs) / 4)))) break;
+		return LD_DWORD(&fs->win[((WORD)clst * 4) & (SS(fs) - 1)]) & 0x0FFFFFFF;
+	}
+
+	return 0xFFFFFFFF;	/* An error occured at the disk I/O layer */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT access - Change value of a FAT entry                              */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+
+FRESULT put_fat (
+	FATFS *fs,	/* File system object */
+	DWORD clst,	/* Cluster# to be changed in range of 2 to fs->max_clust - 1 */
+	DWORD val	/* New value to mark the cluster */
+)
+{
+	UINT bc;
+	BYTE *p;
+	DWORD fsect;
+	FRESULT res;
+
+
+	if (clst < 2 || clst >= fs->max_clust) {	/* Range check */
+		res = FR_INT_ERR;
+
+	} else {
+		fsect = fs->fatbase;
+		switch (fs->fs_type) {
+		case FS_FAT12 :
+			bc = clst; bc += bc / 2;
+			res = move_window(fs, fsect + (bc / SS(fs)));
+			if (res != FR_OK) break;
+			p = &fs->win[bc & (SS(fs) - 1)];
+			*p = (clst & 1) ? ((*p & 0x0F) | ((BYTE)val << 4)) : (BYTE)val;
+			bc++;
+			fs->wflag = 1;
+			res = move_window(fs, fsect + (bc / SS(fs)));
+			if (res != FR_OK) break;
+			p = &fs->win[bc & (SS(fs) - 1)];
+			*p = (clst & 1) ? (BYTE)(val >> 4) : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F));
+			break;
+
+		case FS_FAT16 :
+			res = move_window(fs, fsect + (clst / (SS(fs) / 2)));
+			if (res != FR_OK) break;
+			ST_WORD(&fs->win[((WORD)clst * 2) & (SS(fs) - 1)], (WORD)val);
+			break;
+
+		case FS_FAT32 :
+			res = move_window(fs, fsect + (clst / (SS(fs) / 4)));
+			if (res != FR_OK) break;
+			ST_DWORD(&fs->win[((WORD)clst * 4) & (SS(fs) - 1)], val);
+			break;
+
+		default :
+			res = FR_INT_ERR;
+		}
+		fs->wflag = 1;
+	}
+
+	return res;
+}
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT handling - Remove a cluster chain                                 */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+static
+FRESULT remove_chain (
+	FATFS *fs,			/* File system object */
+	DWORD clst			/* Cluster# to remove a chain from */
+)
+{
+	FRESULT res;
+	DWORD nxt;
+
+
+	if (clst < 2 || clst >= fs->max_clust) {	/* Check the range of cluster# */
+		res = FR_INT_ERR;
+
+	} else {
+		res = FR_OK;
+		while (clst < fs->max_clust) {			/* Not a last link? */
+			nxt = get_fat(fs, clst);			/* Get cluster status */
+			if (nxt == 0) break;				/* Empty cluster? */
+			if (nxt == 1) { res = FR_INT_ERR; break; }	/* Internal error? */
+			if (nxt == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }	/* Disk error? */
+			res = put_fat(fs, clst, 0);			/* Mark the cluster "empty" */
+			if (res != FR_OK) break;
+			if (fs->free_clust != 0xFFFFFFFF) {	/* Update FSInfo */
+				fs->free_clust++;
+				fs->fsi_flag = 1;
+			}
+			clst = nxt;	/* Next cluster */
+		}
+	}
+
+	return res;
+}
+#endif
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT handling - Stretch or Create a cluster chain                      */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+static
+DWORD create_chain (	/* 0:No free cluster, 1:Internal error, 0xFFFFFFFF:Disk error, >=2:New cluster# */
+	FATFS *fs,			/* File system object */
+	DWORD clst			/* Cluster# to stretch. 0 means create a new chain. */
+)
+{
+	DWORD cs, ncl, scl, mcl;
+
+
+	mcl = fs->max_clust;
+	if (clst == 0) {		/* Create new chain */
+		scl = fs->last_clust;			/* Get suggested start point */
+		if (scl == 0 || scl >= mcl) scl = 1;
+	}
+	else {					/* Stretch existing chain */
+		cs = get_fat(fs, clst);			/* Check the cluster status */
+		if (cs < 2) return 1;			/* It is an invalid cluster */
+		if (cs < mcl) return cs;		/* It is already followed by next cluster */
+		scl = clst;
+	}
+
+	ncl = scl;				/* Start cluster */
+	for (;;) {
+		ncl++;							/* Next cluster */
+		if (ncl >= mcl) {				/* Wrap around */
+			ncl = 2;
+			if (ncl > scl) return 0;	/* No free custer */
+		}
+		cs = get_fat(fs, ncl);			/* Get the cluster status */
+		if (cs == 0) break;				/* Found a free cluster */
+		if (cs == 0xFFFFFFFF || cs == 1)/* An error occured */
+			return cs;
+		if (ncl == scl) return 0;		/* No free custer */
+	}
+
+	if (put_fat(fs, ncl, 0x0FFFFFFF))	/* Mark the new cluster "in use" */
+		return 0xFFFFFFFF;
+	if (clst != 0) {					/* Link it to the previous one if needed */
+		if (put_fat(fs, clst, ncl))
+			return 0xFFFFFFFF;
+	}
+
+	fs->last_clust = ncl;				/* Update FSINFO */
+	if (fs->free_clust != 0xFFFFFFFF) {
+		fs->free_clust--;
+		fs->fsi_flag = 1;
+	}
+
+	return ncl;		/* Return new cluster number */
+}
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get sector# from cluster#                                             */
+/*-----------------------------------------------------------------------*/
+
+
+DWORD clust2sect (	/* !=0: Sector number, 0: Failed - invalid cluster# */
+	FATFS *fs,		/* File system object */
+	DWORD clst		/* Cluster# to be converted */
+)
+{
+	clst -= 2;
+	if (clst >= (fs->max_clust - 2)) return 0;		/* Invalid cluster# */
+	return clst * fs->csize + fs->database;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Seek directory index                             */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_seek (
+	DIR *dj,		/* Pointer to directory object */
+	WORD idx		/* Directory index number */
+)
+{
+	DWORD clst;
+	WORD ic;
+
+
+	dj->index = idx;
+	clst = dj->sclust;
+	if (clst == 1 || clst >= dj->fs->max_clust)	/* Check start cluster range */
+		return FR_INT_ERR;
+	if (!clst && dj->fs->fs_type == FS_FAT32)	/* Replace cluster# 0 with root cluster# if in FAT32 */
+		clst = dj->fs->dirbase;
+
+	if (clst == 0) {	/* Static table */
+		dj->clust = clst;
+		if (idx >= dj->fs->n_rootdir)		/* Index is out of range */
+			return FR_INT_ERR;
+		dj->sect = dj->fs->dirbase + idx / (SS(dj->fs) / 32);	/* Sector# */
+	}
+	else {				/* Dynamic table */
+		ic = SS(dj->fs) / 32 * dj->fs->csize;	/* Entries per cluster */
+		while (idx >= ic) {	/* Follow cluster chain */
+			clst = get_fat(dj->fs, clst);				/* Get next cluster */
+			if (clst == 0xFFFFFFFF) return FR_DISK_ERR;	/* Disk error */
+			if (clst < 2 || clst >= dj->fs->max_clust)	/* Reached to end of table or int error */
+				return FR_INT_ERR;
+			idx -= ic;
+		}
+		dj->clust = clst;
+		dj->sect = clust2sect(dj->fs, clst) + idx / (SS(dj->fs) / 32);	/* Sector# */
+	}
+
+	dj->dir = dj->fs->win + (idx % (SS(dj->fs) / 32)) * 32;	/* Ptr to the entry in the sector */
+
+	return FR_OK;	/* Seek succeeded */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Move directory index next                        */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_next (	/* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT and could not streach */
+	DIR *dj,		/* Pointer to directory object */
+	BOOL streach	/* FALSE: Do not streach table, TRUE: Streach table if needed */
+)
+{
+	DWORD clst;
+	WORD i;
+
+
+	i = dj->index + 1;
+	if (!i || !dj->sect)	/* Report EOT when index has reached 65535 */
+		return FR_NO_FILE;
+
+	if (!(i % (SS(dj->fs) / 32))) {	/* Sector changed? */
+		dj->sect++;					/* Next sector */
+
+		if (dj->clust == 0) {	/* Static table */
+			if (i >= dj->fs->n_rootdir)	/* Report EOT when end of table */
+				return FR_NO_FILE;
+		}
+		else {					/* Dynamic table */
+			if (((i / (SS(dj->fs) / 32)) & (dj->fs->csize - 1)) == 0) {	/* Cluster changed? */
+				clst = get_fat(dj->fs, dj->clust);				/* Get next cluster */
+				if (clst <= 1) return FR_INT_ERR;
+				if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
+				if (clst >= dj->fs->max_clust) {				/* When it reached end of dynamic table */
+#if !_FS_READONLY
+					BYTE c;
+					if (!streach) return FR_NO_FILE;			/* When do not streach, report EOT */
+					clst = create_chain(dj->fs, dj->clust);		/* Streach cluster chain */
+					if (clst == 0) return FR_DENIED;			/* No free cluster */
+					if (clst == 1) return FR_INT_ERR;
+					if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
+					/* Clean-up streached table */
+					if (move_window(dj->fs, 0)) return FR_DISK_ERR;	/* Flush active window */
+					mem_set(dj->fs->win, 0, SS(dj->fs));			/* Clear window buffer */
+					dj->fs->winsect = clust2sect(dj->fs, clst);	/* Cluster start sector */
+					for (c = 0; c < dj->fs->csize; c++) {		/* Fill the new cluster with 0 */
+						dj->fs->wflag = 1;
+						if (move_window(dj->fs, 0)) return FR_DISK_ERR;
+						dj->fs->winsect++;
+					}
+					dj->fs->winsect -= c;						/* Rewind window address */
+#else
+					return FR_NO_FILE;			/* Report EOT */
+#endif
+				}
+				dj->clust = clst;				/* Initialize data for new cluster */
+				dj->sect = clust2sect(dj->fs, clst);
+			}
+		}
+	}
+
+	dj->index = i;
+	dj->dir = dj->fs->win + (i % (SS(dj->fs) / 32)) * 32;
+
+	return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* LFN handling - Test/Pick/Fit an LFN segment from/to directory entry   */
+/*-----------------------------------------------------------------------*/
+#if _USE_LFN
+static
+const BYTE LfnOfs[] = {1,3,5,7,9,14,16,18,20,22,24,28,30};	/* Offset of LFN chars in the directory entry */
+
+
+static
+BOOL cmp_lfn (			/* TRUE:Matched, FALSE:Not matched */
+	WCHAR *lfnbuf,		/* Pointer to the LFN to be compared */
+	BYTE *dir			/* Pointer to the directory entry containing a part of LFN */
+)
+{
+	int i, s;
+	WCHAR wc, uc;
+
+
+	i = ((dir[LDIR_Ord] & 0xBF) - 1) * 13;	/* Get offset in the LFN buffer */
+	s = 0; wc = 1;
+	do {
+		uc = LD_WORD(dir+LfnOfs[s]);	/* Pick an LFN character from the entry */
+		if (wc) {	/* Last char has not been processed */
+			wc = ff_wtoupper(uc);		/* Convert it to upper case */
+			if (i >= _MAX_LFN || wc != ff_wtoupper(lfnbuf[i++]))	/* Compare it */
+				return FALSE;			/* Not matched */
+		} else {
+			if (uc != 0xFFFF) return FALSE;	/* Check filler */
+		}
+	} while (++s < 13);				/* Repeat until all chars in the entry are checked */
+
+	if ((dir[LDIR_Ord] & 0x40) && wc && lfnbuf[i])	/* Last segment matched but different length */
+		return FALSE;
+
+	return TRUE;					/* The part of LFN matched */
+}
+
+
+
+static
+BOOL pick_lfn (			/* TRUE:Succeeded, FALSE:Buffer overflow */
+	WCHAR *lfnbuf,		/* Pointer to the Unicode-LFN buffer */
+	BYTE *dir			/* Pointer to the directory entry */
+)
+{
+	int i, s;
+	WCHAR wc, uc;
+
+
+	i = ((dir[LDIR_Ord] & 0x3F) - 1) * 13;	/* Offset in the LFN buffer */
+
+	s = 0; wc = 1;
+	do {
+		uc = LD_WORD(dir+LfnOfs[s]);			/* Pick an LFN character from the entry */
+		if (wc) {	/* Last char has not been processed */
+			if (i >= _MAX_LFN) return FALSE;	/* Buffer overflow? */
+			lfnbuf[i++] = wc = uc;				/* Store it */
+		} else {
+			if (uc != 0xFFFF) return FALSE;		/* Check filler */
+		}
+	} while (++s < 13);						/* Read all character in the entry */
+
+	if (dir[LDIR_Ord] & 0x40) {				/* Put terminator if it is the last LFN part */
+		if (i >= _MAX_LFN) return FALSE;	/* Buffer overflow? */
+		lfnbuf[i] = 0;
+	}
+
+	return TRUE;
+}
+
+
+#if !_FS_READONLY
+static
+void fit_lfn (
+	const WCHAR *lfnbuf,	/* Pointer to the LFN buffer */
+	BYTE *dir,				/* Pointer to the directory entry */
+	BYTE ord,				/* LFN order (1-20) */
+	BYTE sum				/* SFN sum */
+)
+{
+	int i, s;
+	WCHAR wc;
+
+
+	dir[LDIR_Chksum] = sum;			/* Set check sum */
+	dir[LDIR_Attr] = AM_LFN;		/* Set attribute. LFN entry */
+	dir[LDIR_Type] = 0;
+	ST_WORD(dir+LDIR_FstClusLO, 0);
+
+	i = (ord - 1) * 13;				/* Get offset in the LFN buffer */
+	s = wc = 0;
+	do {
+		if (wc != 0xFFFF) wc = lfnbuf[i++];	/* Get an effective char */
+		ST_WORD(dir+LfnOfs[s], wc);	/* Put it */
+		if (!wc) wc = 0xFFFF;		/* Padding chars following last char */
+	} while (++s < 13);
+	if (wc == 0xFFFF || !lfnbuf[i]) ord |= 0x40;	/* Bottom LFN part is the start of LFN sequence */
+	dir[LDIR_Ord] = ord;			/* Set the LFN order */
+}
+
+#endif
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Create numbered name                                                  */
+/*-----------------------------------------------------------------------*/
+#if _USE_LFN
+void gen_numname (
+	BYTE *dst,			/* Pointer to genartated SFN */
+	const BYTE *src,	/* Pointer to source SFN to be modified */
+	const WCHAR *lfn,	/* Pointer to LFN */
+	WORD num			/* Sequense number */
+)
+{
+	char ns[8];
+	int i, j;
+
+
+	mem_cpy(dst, src, 11);
+
+	if (num > 5) {	/* On many collisions, generate a hash number instead of sequencial number */
+		do num = (num >> 1) + (num << 15) + (WORD)*lfn++; while (*lfn);
+	}
+
+	/* itoa */
+	i = 7;
+	do {
+		ns[i--] = (num % 10) + '0';
+		num /= 10;
+	} while (num);
+	ns[i] = '~';
+
+	/* Append the number */
+	for (j = 0; j < i && dst[j] != ' '; j++) {
+		if (IsDBCS1(dst[j])) {
+			if (j == i - 1) break;
+			j++;
+		}
+	}
+	do {
+		dst[j++] = (i < 8) ? ns[i++] : ' ';
+	} while (j < 8);
+}
+#endif
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Calculate sum of an SFN                                               */
+/*-----------------------------------------------------------------------*/
+#if _USE_LFN
+static
+BYTE sum_sfn (
+	const BYTE *dir		/* Ptr to directory entry */
+)
+{
+	BYTE sum = 0;
+	int n = 11;
+
+	do sum = (sum >> 1) + (sum << 7) + *dir++; while (--n);
+	return sum;
+}
+#endif
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Find an object in the directory                  */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_find (
+	DIR *dj			/* Pointer to the directory object linked to the file name */
+)
+{
+	FRESULT res;
+	BYTE c, *dir;
+#if _USE_LFN
+	BYTE a, ord, sum;
+#endif
+
+	res = dir_seek(dj, 0);			/* Rewind directory object */
+	if (res != FR_OK) return res;
+
+#if _USE_LFN
+	ord = sum = 0xFF;
+#endif
+	do {
+		res = move_window(dj->fs, dj->sect);
+		if (res != FR_OK) break;
+		dir = dj->dir;					/* Ptr to the directory entry of current index */
+		c = dir[DIR_Name];
+		if (c == 0) { res = FR_NO_FILE; break; }	/* Reached to end of table */
+#if _USE_LFN	/* LFN configuration */
+		a = dir[DIR_Attr] & AM_MASK;
+		if (c == 0xE5 || ((a & AM_VOL) && a != AM_LFN)) {	/* An entry without valid data */
+			ord = 0xFF;
+		} else {
+			if (a == AM_LFN) {			/* An LFN entry is found */
+				if (dj->lfn) {
+					if (c & 0x40) {		/* Is it start of LFN sequence? */
+						sum = dir[LDIR_Chksum];
+						c &= 0xBF; ord = c;	/* LFN start order */
+						dj->lfn_idx = dj->index;
+					}
+					/* Check validity of the LFN entry and compare it with given name */
+					ord = (c == ord && sum == dir[LDIR_Chksum] && cmp_lfn(dj->lfn, dir)) ? ord - 1 : 0xFF;
+				}
+			} else {					/* An SFN entry is found */
+				if (!ord && sum == sum_sfn(dir)) break;	/* LFN matched? */
+				ord = 0xFF; dj->lfn_idx = 0xFFFF;	/* Reset LFN sequence */
+				if (!(dj->fn[NS] & NS_LOSS) && !mem_cmp(dir, dj->fn, 11)) break;	/* SFN matched? */
+			}
+		}
+#else		/* Non LFN configuration */
+		if (!(dir[DIR_Attr] & AM_VOL) && !mem_cmp(dir, dj->fn, 11)) /* Is it a valid entry? */
+			break;
+#endif
+		res = dir_next(dj, FALSE);		/* Next entry */
+	} while (res == FR_OK);
+
+	return res;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read an object from the directory                                     */
+/*-----------------------------------------------------------------------*/
+#if _FS_MINIMIZE <= 1
+static
+FRESULT dir_read (
+	DIR *dj			/* Pointer to the directory object that pointing the entry to be read */
+)
+{
+	FRESULT res;
+	BYTE c, *dir;
+#if _USE_LFN
+	BYTE a, ord = 0xFF, sum = 0xFF;
+#endif
+
+	res = FR_NO_FILE;
+	while (dj->sect) {
+		res = move_window(dj->fs, dj->sect);
+		if (res != FR_OK) break;
+		dir = dj->dir;					/* Ptr to the directory entry of current index */
+		c = dir[DIR_Name];
+		if (c == 0) { res = FR_NO_FILE; break; }	/* Reached to end of table */
+#if _USE_LFN	/* LFN configuration */
+		a = dir[DIR_Attr] & AM_MASK;
+		if (c == 0xE5 || (!_FS_RPATH && c == '.') || ((a & AM_VOL) && a != AM_LFN)) {	/* An entry without valid data */
+			ord = 0xFF;
+		} else {
+			if (a == AM_LFN) {			/* An LFN entry is found */
+				if (c & 0x40) {			/* Is it start of LFN sequence? */
+					sum = dir[LDIR_Chksum];
+					c &= 0xBF; ord = c;
+					dj->lfn_idx = dj->index;
+				}
+				/* Check LFN validity and capture it */
+				ord = (c == ord && sum == dir[LDIR_Chksum] && pick_lfn(dj->lfn, dir)) ? ord - 1 : 0xFF;
+			} else {					/* An SFN entry is found */
+				if (ord || sum != sum_sfn(dir))	/* Is there a valid LFN? */
+					dj->lfn_idx = 0xFFFF;		/* It has no LFN. */
+				break;
+			}
+		}
+#else		/* Non LFN configuration */
+		if (c != 0xE5 && (_FS_RPATH || c != '.') && !(dir[DIR_Attr] & AM_VOL))	/* Is it a valid entry? */
+			break;
+#endif
+		res = dir_next(dj, FALSE);				/* Next entry */
+		if (res != FR_OK) break;
+	}
+
+	if (res != FR_OK) dj->sect = 0;
+
+	return res;
+}
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Register an object to the directory                                   */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+static
+FRESULT dir_register (	/* FR_OK:Successful, FR_DENIED:No free entry or too many SFN collision, FR_DISK_ERR:Disk error */
+	DIR *dj				/* Target directory with object name to be created */
+)
+{
+	FRESULT res;
+	BYTE c, *dir;
+#if _USE_LFN	/* LFN configuration */
+	WORD n, ne, is;
+	BYTE sn[12], *fn, sum;
+	WCHAR *lfn;
+
+
+	fn = dj->fn; lfn = dj->lfn;
+	mem_cpy(sn, fn, 12);
+
+	if (_FS_RPATH && (sn[NS] & NS_DOT)) return FR_INVALID_NAME;	/* Cannot create dot entry */
+
+	if (sn[NS] & NS_LOSS) {			/* When LFN is out of 8.3 format, generate a numbered name */
+		fn[NS] = 0; dj->lfn = NULL;			/* Find only SFN */
+		for (n = 1; n < 100; n++) {
+			gen_numname(fn, sn, lfn, n);	/* Generate a numbered name */
+			res = dir_find(dj);				/* Check if the name collides with existing SFN */
+			if (res != FR_OK) break;
+		}
+		if (n == 100) return FR_DENIED;		/* Abort if too many collisions */
+		if (res != FR_NO_FILE) return res;	/* Abort if the result is other than 'not collided' */
+		fn[NS] = sn[NS]; dj->lfn = lfn;
+	}
+
+	if (sn[NS] & NS_LFN) {			/* When LFN is to be created, reserve reserve an SFN + LFN entries. */
+		for (ne = 0; lfn[ne]; ne++) ;
+		ne = (ne + 25) / 13;
+	} else {						/* Otherwise reserve only an SFN entry. */
+		ne = 1;
+	}
+
+	/* Reserve contiguous entries */
+	res = dir_seek(dj, 0);
+	if (res != FR_OK) return res;
+	n = is = 0;
+	do {
+		res = move_window(dj->fs, dj->sect);
+		if (res != FR_OK) break;
+		c = *dj->dir;				/* Check the entry status */
+		if (c == 0xE5 || c == 0) {	/* Is it a blank entry? */
+			if (n == 0) is = dj->index;	/* First index of the contigulus entry */
+			if (++n == ne) break;	/* A contiguous entry that requiered count is found */
+		} else {
+			n = 0;					/* Not a blank entry. Restart to search */
+		}
+		res = dir_next(dj, TRUE);	/* Next entry with table streach */
+	} while (res == FR_OK);
+
+	if (res == FR_OK && ne > 1) {	/* Initialize LFN entry if needed */
+		res = dir_seek(dj, is);
+		if (res == FR_OK) {
+			sum = sum_sfn(dj->fn);	/* Sum of the SFN tied to the LFN */
+			ne--;
+			do {					/* Store LFN entries in bottom first */
+				res = move_window(dj->fs, dj->sect);
+				if (res != FR_OK) break;
+				fit_lfn(dj->lfn, dj->dir, (BYTE)ne, sum);
+				dj->fs->wflag = 1;
+				res = dir_next(dj, FALSE);	/* Next entry */
+			} while (res == FR_OK && --ne);
+		}
+	}
+
+#else	/* Non LFN configuration */
+	res = dir_seek(dj, 0);
+	if (res == FR_OK) {
+		do {	/* Find a blank entry for the SFN */
+			res = move_window(dj->fs, dj->sect);
+			if (res != FR_OK) break;
+			c = *dj->dir;
+			if (c == 0xE5 || c == 0) break;	/* Is it a blank entry? */
+			res = dir_next(dj, TRUE);		/* Next entry with table streach */
+		} while (res == FR_OK);
+	}
+#endif
+
+	if (res == FR_OK) {		/* Initialize the SFN entry */
+		res = move_window(dj->fs, dj->sect);
+		if (res == FR_OK) {
+			dir = dj->dir;
+			mem_set(dir, 0, 32);		/* Clean the entry */
+			mem_cpy(dir, dj->fn, 11);	/* Put SFN */
+			dir[DIR_NTres] = *(dj->fn+NS) & (NS_BODY | NS_EXT);	/* Put NT flag */
+			dj->fs->wflag = 1;
+		}
+	}
+
+	return res;
+}
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Remove an object from the directory                                   */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY && !_FS_MINIMIZE
+static
+FRESULT dir_remove (	/* FR_OK: Successful, FR_DISK_ERR: A disk error */
+	DIR *dj				/* Directory object pointing the entry to be removed */
+)
+{
+	FRESULT res;
+#if _USE_LFN	/* LFN configuration */
+	WORD i;
+
+	i = dj->index;	/* SFN index */
+	res = dir_seek(dj, (WORD)((dj->lfn_idx == 0xFFFF) ? i : dj->lfn_idx));	/* Goto the SFN or top of the LFN entries */
+	if (res == FR_OK) {
+		do {
+			res = move_window(dj->fs, dj->sect);
+			if (res != FR_OK) break;
+			*dj->dir = 0xE5;			/* Mark the entry "deleted" */
+			dj->fs->wflag = 1;
+			if (dj->index >= i) break;	/* When reached SFN, all entries of the object has been deleted. */
+			res = dir_next(dj, FALSE);	/* Next entry */
+		} while (res == FR_OK);
+		if (res == FR_NO_FILE) res = FR_INT_ERR;
+	}
+
+#else			/* Non LFN configuration */
+	res = dir_seek(dj, dj->index);
+	if (res == FR_OK) {
+		res = move_window(dj->fs, dj->sect);
+		if (res == FR_OK) {
+			*dj->dir = 0xE5;			/* Mark the entry "deleted" */
+			dj->fs->wflag = 1;
+		}
+	}
+#endif
+
+	return res;
+}
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Pick a segment and create the object name in directory form           */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT create_name (
+	DIR *dj,			/* Pointer to the directory object */
+	const XCHAR **path	/* Pointer to pointer to the segment in the path string */
+)
+{
+#ifdef _EXCVT
+	static const BYTE cvt[] = _EXCVT;
+#endif
+
+#if _USE_LFN	/* LFN configuration */
+	BYTE b, cf;
+	WCHAR w, *lfn;
+	int i, ni, si, di;
+	const XCHAR *p;
+
+	/* Create LFN in Unicode */
+	si = di = 0;
+	p = *path;
+	lfn = dj->lfn;
+	for (;;) {
+		w = p[si++];					/* Get a character */
+		if (w < ' ' || w == '/' || w == '\\') break;	/* Break on end of segment */
+		if (di >= _MAX_LFN)				/* Reject too long name */
+			return FR_INVALID_NAME;
+#if !_LFN_UNICODE
+		w &= 0xFF;
+		if (IsDBCS1(w)) {				/* If it is a DBC 1st byte */
+			b = p[si++];				/* Get 2nd byte */
+			if (!IsDBCS2(b))			/* Reject invalid code for DBC */
+				return FR_INVALID_NAME;
+			w = (w << 8) + b;
+		}
+		w = ff_convert(w, 1);			/* Convert OEM to Unicode */
+		if (!w) return FR_INVALID_NAME;	/* Reject invalid code */
+#endif
+		if (w < 0x80 && chk_chr("\"*:<>\?|\x7F", w)) /* Reject illegal chars for LFN */
+			return FR_INVALID_NAME;
+		lfn[di++] = w;					/* Store the Unicode char */
+	}
+	*path = &p[si];						/* Rerurn pointer to the next segment */
+	cf = (w < ' ') ? NS_LAST : 0;		/* Set last segment flag if end of path */
+#if _FS_RPATH
+	if ((di == 1 && lfn[di - 1] == '.') || /* Is this a dot entry? */
+		(di == 2 && lfn[di - 1] == '.' && lfn[di - 2] == '.')) {
+		lfn[di] = 0;
+		for (i = 0; i < 11; i++)
+			dj->fn[i] = (i < di) ? '.' : ' ';
+		dj->fn[i] = cf | NS_DOT;		/* This is a dot entry */
+		return FR_OK;
+	}
+#endif
+	while (di) {						/* Strip trailing spaces and dots */
+		w = lfn[di - 1];
+		if (w != ' ' && w != '.') break;
+		di--;
+	}
+	if (!di) return FR_INVALID_NAME;	/* Reject null string */
+
+	lfn[di] = 0;						/* LFN is created */
+
+	/* Create SFN in directory form */
+	mem_set(dj->fn, ' ', 11);
+	for (si = 0; lfn[si] == ' ' || lfn[si] == '.'; si++) ;	/* Strip leading spaces and dots */
+	if (si) cf |= NS_LOSS | NS_LFN;
+	while (di && lfn[di - 1] != '.') di--;	/* Find extension (di<=si: no extension) */
+
+	b = i = 0; ni = 8;
+	for (;;) {
+		w = lfn[si++];					/* Get an LFN char */
+		if (!w) break;					/* Break on enf of the LFN */
+		if (w == ' ' || (w == '.' && si != di)) {	/* Remove spaces and dots */
+			cf |= NS_LOSS | NS_LFN; continue;
+		}
+
+		if (i >= ni || si == di) {		/* Extension or end of SFN */
+			if (ni == 11) {				/* Long extension */
+				cf |= NS_LOSS | NS_LFN; break;
+			}
+			if (si != di) cf |= NS_LOSS | NS_LFN;	/* Out of 8.3 format */
+			if (si > di) break;			/* No extension */
+			si = di; i = 8; ni = 11;	/* Enter extension section */
+			b <<= 2; continue;
+		}
+
+		if (w >= 0x80) {				/* Non ASCII char */
+#ifdef _EXCVT
+			w = ff_convert(w, 0);		/* Unicode -> OEM code */
+			if (w) w = cvt[w - 0x80];	/* Convert extended char to upper (SBCS) */
+#else
+			w = ff_convert(ff_wtoupper(w), 0);	/* Upper converted Unicode -> OEM code */
+#endif
+			cf |= NS_LFN;				/* Force create LFN entry */
+		}
+
+		if (_DF1S && w >= 0x100) {		/* Double byte char */
+			if (i >= ni - 1) {
+				cf |= NS_LOSS | NS_LFN; i = ni; continue;
+			}
+			dj->fn[i++] = (BYTE)(w >> 8);
+		} else {						/* Single byte char */
+			if (!w || chk_chr("+,;[=]", w)) {		/* Replace illegal chars for SFN */
+				w = '_'; cf |= NS_LOSS | NS_LFN;	/* Lossy conversion */
+			} else {
+				if (IsUpper(w)) {		/* ASCII large capital */
+					b |= 2;
+				} else {
+					if (IsLower(w)) {	/* ASCII small capital */
+						b |= 1; w -= 0x20;
+					}
+				}
+			}
+		}
+		dj->fn[i++] = (BYTE)w;
+	}
+
+	if (dj->fn[0] == 0xE5) dj->fn[0] = 0x05;	/* If the first char collides with deleted mark, replace it with 0x05 */
+
+	if (ni == 8) b <<= 2;
+	if ((b & 0x0C) == 0x0C || (b & 0x03) == 0x03)	/* Create LFN entry when there are composite capitals */
+		cf |= NS_LFN;
+	if (!(cf & NS_LFN)) {						/* When LFN is in 8.3 format without extended char, NT flags are created */
+		if ((b & 0x03) == 0x01) cf |= NS_EXT;	/* NT flag (Extension has only small capital) */
+		if ((b & 0x0C) == 0x04) cf |= NS_BODY;	/* NT flag (Filename has only small capital) */
+	}
+
+	dj->fn[NS] = cf;	/* SFN is created */
+
+	return FR_OK;
+
+
+#else	/* Non-LFN configuration */
+	BYTE b, c, d, *sfn;
+	int ni, si, i;
+	const char *p;
+
+	/* Create file name in directory form */
+	sfn = dj->fn;
+	mem_set(sfn, ' ', 11);
+	si = i = b = 0; ni = 8;
+	p = *path;
+#if _FS_RPATH
+	if (p[si] == '.') { /* Is this a dot entry? */
+		for (;;) {
+			c = p[si++];
+			if (c != '.' || si >= 3) break;
+			sfn[i++] = c;
+		}
+		if (c != '/' && c != '\\' && c > ' ') return FR_INVALID_NAME;
+		*path = &p[si];									/* Rerurn pointer to the next segment */
+		sfn[NS] = (c <= ' ') ? NS_LAST | NS_DOT : NS_DOT;	/* Set last segment flag if end of path */
+		return FR_OK;
+	}
+#endif
+	for (;;) {
+		c = p[si++];
+		if (c <= ' ' || c == '/' || c == '\\') break;	/* Break on end of segment */
+		if (c == '.' || i >= ni) {
+			if (ni != 8 || c != '.') return FR_INVALID_NAME;
+			i = 8; ni = 11;
+			b <<= 2; continue;
+		}
+		if (c >= 0x80) {				/* Extended char */
+#ifdef _EXCVT
+			c = cvt[c - 0x80];			/* Convert extend char (SBCS) */
+#else
+			b |= 3;						/* Eliminate NT flag if ext char is exist */
+#if !_DF1S	/* ASCII only cfg */
+			return FR_INVALID_NAME;
+#endif
+#endif
+		}
+		if (IsDBCS1(c)) {				/* DBC 1st byte? */
+			d = p[si++];				/* Get 2nd byte */
+			if (!IsDBCS2(d) || i >= ni - 1)	/* Reject invalid DBC */
+				return FR_INVALID_NAME;
+			sfn[i++] = c;
+			sfn[i++] = d;
+		} else {						/* Single byte code */
+			if (chk_chr(" \"*+,[=]|\x7F", c))	/* Reject illegal chrs for SFN */
+				return FR_INVALID_NAME;
+			if (IsUpper(c)) {			/* ASCII large capital? */
+				b |= 2;
+			} else {
+				if (IsLower(c)) {		/* ASCII small capital? */
+					b |= 1; c -= 0x20;
+				}
+			}
+			sfn[i++] = c;
+		}
+	}
+	*path = &p[si];						/* Rerurn pointer to the next segment */
+	c = (c <= ' ') ? NS_LAST : 0;		/* Set last segment flag if end of path */
+
+	if (!i) return FR_INVALID_NAME;		/* Reject null string */
+	if (sfn[0] == 0xE5) sfn[0] = 0x05;	/* When first char collides with 0xE5, replace it with 0x05 */
+
+	if (ni == 8) b <<= 2;
+	if ((b & 0x03) == 0x01) c |= NS_EXT;	/* NT flag (Extension has only small capital) */
+	if ((b & 0x0C) == 0x04) c |= NS_BODY;	/* NT flag (Filename has only small capital) */
+
+	sfn[NS] = c;		/* Store NT flag, File name is created */
+
+	return FR_OK;
+#endif
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get file information from directory entry                             */
+/*-----------------------------------------------------------------------*/
+#if _FS_MINIMIZE <= 1
+static
+void get_fileinfo (		/* No return code */
+	DIR *dj,			/* Pointer to the directory object */
+	FILINFO *fno	 	/* Pointer to the file information to be filled */
+)
+{
+	int i;
+	BYTE c, nt, *dir;
+	char *p;
+
+
+	p = fno->fname;
+	if (dj->sect) {
+		dir = dj->dir;
+		nt = dir[DIR_NTres];		/* NT flag */
+		for (i = 0; i < 8; i++) {	/* Copy name body */
+			c = dir[i];
+			if (c == ' ') break;
+			if (c == 0x05) c = 0xE5;
+			if (_USE_LFN && (nt & NS_BODY) && IsUpper(c)) c += 0x20;
+			*p++ = c;
+		}
+		if (dir[8] != ' ') {		/* Copy name extension */
+			*p++ = '.';
+			for (i = 8; i < 11; i++) {
+				c = dir[i];
+				if (c == ' ') break;
+				if (_USE_LFN && (nt & NS_EXT) && IsUpper(c)) c += 0x20;
+				*p++ = c;
+			}
+		}
+		fno->fattrib = dir[DIR_Attr];				/* Attribute */
+		fno->fsize = LD_DWORD(dir+DIR_FileSize);	/* Size */
+		fno->fdate = LD_WORD(dir+DIR_WrtDate);		/* Date */
+		fno->ftime = LD_WORD(dir+DIR_WrtTime);		/* Time */
+	}
+	*p = 0;
+
+#if _USE_LFN
+	if (fno->lfname) {
+		XCHAR *tp = fno->lfname;
+		WCHAR w, *lfn;
+
+		i = 0;
+		if (dj->sect && dj->lfn_idx != 0xFFFF) {/* Get LFN if available */
+			lfn = dj->lfn;
+			while ((w = *lfn++) != 0) {			/* Get an LFN char */
+#if !_LFN_UNICODE
+				w = ff_convert(w, 0);			/* Unicode -> OEM conversion */
+				if (!w) { i = 0; break; }		/* Could not convert, no LFN */
+				if (_DF1S && w >= 0x100)		/* Put 1st byte if it is a DBC */
+					tp[i++] = (XCHAR)(w >> 8);
+#endif
+				if (i >= fno->lfsize - 1) { i = 0; break; }	/* Buffer overrun, no LFN */
+				tp[i++] = (XCHAR)w;
+			}
+		}
+		tp[i] = 0;	/* Terminator */
+	}
+#endif
+}
+#endif /* _FS_MINIMIZE <= 1 */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Follow a file path                                                    */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT follow_path (	/* FR_OK(0): successful, !=0: error code */
+	DIR *dj,			/* Directory object to return last directory and found object */
+	const XCHAR *path	/* Full-path string to find a file or directory */
+)
+{
+	FRESULT res;
+	BYTE *dir, last;
+
+
+	while (!_USE_LFN && *path == ' ') path++;	/* Skip leading spaces */
+#if _FS_RPATH
+	if (*path == '/' || *path == '\\') { /* There is a heading separator */
+		path++;	dj->sclust = 0;		/* Strip it and start from the root dir */
+	} else {							/* No heading saparator */
+		dj->sclust = dj->fs->cdir;	/* Start from the current dir */
+	}
+#else
+	if (*path == '/' || *path == '\\')	/* Strip heading separator if exist */
+		path++;
+	dj->sclust = 0;						/* Start from the root dir */
+#endif
+
+	if ((UINT)*path < ' ') {			/* Null path means the start directory itself */
+		res = dir_seek(dj, 0);
+		dj->dir = NULL;
+
+	} else {							/* Follow path */
+		for (;;) {
+			res = create_name(dj, &path);	/* Get a segment */
+			if (res != FR_OK) break;
+			res = dir_find(dj);				/* Find it */
+			last = *(dj->fn+NS) & NS_LAST;
+			if (res != FR_OK) {				/* Could not find the object */
+				if (res == FR_NO_FILE && !last)
+					res = FR_NO_PATH;
+				break;
+			}
+			if (last) break;				/* Last segment match. Function completed. */
+			dir = dj->dir;					/* There is next segment. Follow the sub directory */
+			if (!(dir[DIR_Attr] & AM_DIR)) { /* Cannot follow because it is a file */
+				res = FR_NO_PATH; break;
+			}
+			dj->sclust = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);
+		}
+	}
+
+	return res;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Load boot record and check if it is an FAT boot record                */
+/*-----------------------------------------------------------------------*/
+
+static
+BYTE check_fs (	/* 0:The FAT boot record, 1:Valid boot record but not an FAT, 2:Not a boot record, 3:Error */
+	FATFS *fs,	/* File system object */
+	DWORD sect	/* Sector# (lba) to check if it is an FAT boot record or not */
+)
+{
+	if (disk_read(fs->drive, fs->win, sect, 1) != RES_OK)	/* Load boot record */
+		return 3;
+	if (LD_WORD(&fs->win[BS_55AA]) != 0xAA55)		/* Check record signature (always placed at offset 510 even if the sector size is >512) */
+		return 2;
+
+	if ((LD_DWORD(&fs->win[BS_FilSysType]) & 0xFFFFFF) == 0x544146)	/* Check "FAT" string */
+		return 0;
+	if ((LD_DWORD(&fs->win[BS_FilSysType32]) & 0xFFFFFF) == 0x544146)
+		return 0;
+
+	return 1;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Make sure that the file system is valid                               */
+/*-----------------------------------------------------------------------*/
+
+
+FRESULT chk_mounted (	/* FR_OK(0): successful, !=0: any error occured */
+	const XCHAR **path,	/* Pointer to pointer to the path name (drive number) */
+	FATFS **rfs,		/* Pointer to pointer to the found file system object */
+	BYTE chk_wp			/* !=0: Check media write protection for write access */
+)
+{
+	BYTE fmt, *tbl;
+	UINT vol;
+	DSTATUS stat;
+	DWORD bsect, fsize, tsect, mclst;
+	const XCHAR *p = *path;
+	FATFS *fs;
+
+	/* Get logical drive number from the path name */
+	vol = p[0] - '0';				/* Is there a drive number? */
+	if (vol <= 9 && p[1] == ':') {	/* Found a drive number, get and strip it */
+		p += 2; *path = p;			/* Return pointer to the path name */
+	} else {						/* No drive number is given */
+#if _FS_RPATH
+		vol = Drive;				/* Use current drive */
+#else
+		vol = 0;					/* Use drive 0 */
+#endif
+	}
+
+	/* Check if the logical drive is valid or not */
+	if (vol >= _DRIVES) 			/* Is the drive number valid? */
+		return FR_INVALID_DRIVE;
+	*rfs = fs = FatFs[vol];			/* Returen pointer to the corresponding file system object */
+	if (!fs) return FR_NOT_ENABLED;	/* Is the file system object available? */
+
+	ENTER_FF(fs);					/* Lock file system */
+
+	if (fs->fs_type) {				/* If the logical drive has been mounted */
+		stat = disk_status(fs->drive);
+		if (!(stat & STA_NOINIT)) {	/* and the physical drive is kept initialized (has not been changed), */
+#if !_FS_READONLY
+			if (chk_wp && (stat & STA_PROTECT))	/* Check write protection if needed */
+				return FR_WRITE_PROTECTED;
+#endif
+			return FR_OK;			/* The file system object is valid */
+		}
+	}
+
+	/* The logical drive must be mounted. Following code attempts to mount the volume */
+
+	fs->fs_type = 0;					/* Clear the file system object */
+	fs->drive = (BYTE)LD2PD(vol);		/* Bind the logical drive and a physical drive */
+	stat = disk_initialize(fs->drive);	/* Initialize low level disk I/O layer */
+	if (stat & STA_NOINIT)				/* Check if the drive is ready */
+		return FR_NOT_READY;
+#if _MAX_SS != 512						/* Get disk sector size if needed */
+	if (disk_ioctl(fs->drive, GET_SECTOR_SIZE, &SS(fs)) != RES_OK || SS(fs) > _MAX_SS)
+		return FR_NO_FILESYSTEM;
+#endif
+#if !_FS_READONLY
+	if (chk_wp && (stat & STA_PROTECT))	/* Check disk write protection if needed */
+		return FR_WRITE_PROTECTED;
+#endif
+	/* Search FAT partition on the drive */
+	fmt = check_fs(fs, bsect = 0);		/* Check sector 0 as an SFD format */
+	if (fmt == 1) {						/* Not an FAT boot record, it may be patitioned */
+		/* Check a partition listed in top of the partition table */
+		tbl = &fs->win[MBR_Table + LD2PT(vol) * 16];	/* Partition table */
+		if (tbl[4]) {									/* Is the partition existing? */
+			bsect = LD_DWORD(&tbl[8]);					/* Partition offset in LBA */
+			fmt = check_fs(fs, bsect);					/* Check the partition */
+		}
+	}
+	if (fmt == 3) return FR_DISK_ERR;
+	if (fmt || LD_WORD(fs->win+BPB_BytsPerSec) != SS(fs))	/* No valid FAT patition is found */
+		return FR_NO_FILESYSTEM;
+
+	/* Initialize the file system object */
+	fsize = LD_WORD(fs->win+BPB_FATSz16);				/* Number of sectors per FAT */
+	if (!fsize) fsize = LD_DWORD(fs->win+BPB_FATSz32);
+	fs->sects_fat = fsize;
+	fs->n_fats = fs->win[BPB_NumFATs];					/* Number of FAT copies */
+	fsize *= fs->n_fats;								/* (Number of sectors in FAT area) */
+	fs->fatbase = bsect + LD_WORD(fs->win+BPB_RsvdSecCnt); /* FAT start sector (lba) */
+	fs->csize = fs->win[BPB_SecPerClus];				/* Number of sectors per cluster */
+	fs->n_rootdir = LD_WORD(fs->win+BPB_RootEntCnt);	/* Nmuber of root directory entries */
+	tsect = LD_WORD(fs->win+BPB_TotSec16);				/* Number of sectors on the volume */
+	if (!tsect) tsect = LD_DWORD(fs->win+BPB_TotSec32);
+	fs->max_clust = mclst = (tsect						/* Last cluster# + 1 (Number of clusters + 2) */
+		- LD_WORD(fs->win+BPB_RsvdSecCnt) - fsize - fs->n_rootdir / (SS(fs)/32)
+		) / fs->csize + 2;
+
+	fmt = FS_FAT12;										/* Determine the FAT sub type */
+	if (mclst >= 0xFF7) fmt = FS_FAT16;					/* Number of clusters >= 0xFF5 */
+	if (mclst >= 0xFFF7) fmt = FS_FAT32;				/* Number of clusters >= 0xFFF5 */
+
+	if (fmt == FS_FAT32)
+		fs->dirbase = LD_DWORD(fs->win+BPB_RootClus);	/* Root directory start cluster */
+	else
+		fs->dirbase = fs->fatbase + fsize;				/* Root directory start sector (lba) */
+	fs->database = fs->fatbase + fsize + fs->n_rootdir / (SS(fs)/32);	/* Data start sector (lba) */
+
+#if !_FS_READONLY
+	/* Initialize allocation information */
+	fs->free_clust = 0xFFFFFFFF;
+	fs->wflag = 0;
+	/* Get fsinfo if needed */
+	if (fmt == FS_FAT32) {
+	 	fs->fsi_flag = 0;
+		fs->fsi_sector = bsect + LD_WORD(fs->win+BPB_FSInfo);
+		if (disk_read(fs->drive, fs->win, fs->fsi_sector, 1) == RES_OK &&
+			LD_WORD(fs->win+BS_55AA) == 0xAA55 &&
+			LD_DWORD(fs->win+FSI_LeadSig) == 0x41615252 &&
+			LD_DWORD(fs->win+FSI_StrucSig) == 0x61417272) {
+			fs->last_clust = LD_DWORD(fs->win+FSI_Nxt_Free);
+			fs->free_clust = LD_DWORD(fs->win+FSI_Free_Count);
+		}
+	}
+#endif
+	fs->fs_type = fmt;		/* FAT sub-type */
+	fs->winsect = 0;		/* Invalidate sector cache */
+#if _FS_RPATH
+	fs->cdir = 0;			/* Current directory (root dir) */
+#endif
+	fs->id = ++Fsid;		/* File system mount ID */
+
+	return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Check if the file/dir object is valid or not                          */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT validate (	/* FR_OK(0): The object is valid, !=0: Invalid */
+	FATFS *fs,		/* Pointer to the file system object */
+	WORD id			/* Member id of the target object to be checked */
+)
+{
+	if (!fs || !fs->fs_type || fs->id != id)
+		return FR_INVALID_OBJECT;
+
+	ENTER_FF(fs);		/* Lock file system */
+
+	if (disk_status(fs->drive) & STA_NOINIT)
+		return FR_NOT_READY;
+
+	return FR_OK;
+}
+
+
+
+
+/*--------------------------------------------------------------------------
+
+   Public Functions
+
+--------------------------------------------------------------------------*/
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Mount/Unmount a Locical Drive                                         */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_mount (
+	BYTE vol,		/* Logical drive number to be mounted/unmounted */
+	FATFS *fs		/* Pointer to new file system object (NULL for unmount)*/
+)
+{
+	FATFS *rfs;
+
+
+	if (vol >= _DRIVES)				/* Check if the drive number is valid */
+		return FR_INVALID_DRIVE;
+	rfs = FatFs[vol];				/* Get current fs object */
+
+	if (rfs) {
+#if _FS_REENTRANT					/* Discard sync object of the current volume */
+		if (!ff_del_syncobj(rfs->sobj)) return FR_INT_ERR;
+#endif
+		rfs->fs_type = 0;			/* Clear old fs object */
+	}
+
+	if (fs) {
+		fs->fs_type = 0;			/* Clear new fs object */
+#if _FS_REENTRANT					/* Create sync object for the new volume */
+		if (!ff_cre_syncobj(vol, &fs->sobj)) return FR_INT_ERR;
+#endif
+	}
+	FatFs[vol] = fs;				/* Register new fs object */
+
+	return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Open or Create a File                                                 */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_open (
+	FIL *fp,			/* Pointer to the blank file object */
+	const XCHAR *path,	/* Pointer to the file name */
+	BYTE mode			/* Access mode and file open mode flags */
+)
+{
+	FRESULT res;
+	DIR dj;
+	NAMEBUF(sfn, lfn);
+	BYTE *dir;
+
+
+	fp->fs = NULL;		/* Clear file object */
+#if !_FS_READONLY
+	mode &= (FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW);
+	res = chk_mounted(&path, &dj.fs, (BYTE)(mode & (FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)));
+#else
+	mode &= FA_READ;
+	res = chk_mounted(&path, &dj.fs, 0);
+#endif
+	if (res != FR_OK) LEAVE_FF(dj.fs, res);
+	INITBUF(dj, sfn, lfn);
+	res = follow_path(&dj, path);	/* Follow the file path */
+
+#if !_FS_READONLY
+	/* Create or Open a file */
+	if (mode & (FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)) {
+		DWORD ps, cl;
+
+		if (res != FR_OK) {			/* No file, create new */
+			if (res == FR_NO_FILE)	/* There is no file to open, create a new entry */
+				res = dir_register(&dj);
+			if (res != FR_OK) LEAVE_FF(dj.fs, res);
+			mode |= FA_CREATE_ALWAYS;
+			dir = dj.dir;			/* Created entry (SFN entry) */
+		}
+		else {						/* Any object is already existing */
+			if (mode & FA_CREATE_NEW)			/* Cannot create new */
+				LEAVE_FF(dj.fs, FR_EXIST);
+			dir = dj.dir;
+			if (!dir || (dir[DIR_Attr] & (AM_RDO | AM_DIR)))	/* Cannot overwrite it (R/O or DIR) */
+				LEAVE_FF(dj.fs, FR_DENIED);
+			if (mode & FA_CREATE_ALWAYS) {		/* Resize it to zero on over write mode */
+				cl = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);	/* Get start cluster */
+				ST_WORD(dir+DIR_FstClusHI, 0);	/* cluster = 0 */
+				ST_WORD(dir+DIR_FstClusLO, 0);
+				ST_DWORD(dir+DIR_FileSize, 0);	/* size = 0 */
+				dj.fs->wflag = 1;
+				ps = dj.fs->winsect;			/* Remove the cluster chain */
+				if (cl) {
+					res = remove_chain(dj.fs, cl);
+					if (res) LEAVE_FF(dj.fs, res);
+					dj.fs->last_clust = cl - 1;	/* Reuse the cluster hole */
+				}
+				res = move_window(dj.fs, ps);
+				if (res != FR_OK) LEAVE_FF(dj.fs, res);
+			}
+		}
+		if (mode & FA_CREATE_ALWAYS) {
+			dir[DIR_Attr] = 0;					/* Reset attribute */
+			ps = get_fattime();
+			ST_DWORD(dir+DIR_CrtTime, ps);		/* Created time */
+			dj.fs->wflag = 1;
+			mode |= FA__WRITTEN;				/* Set file changed flag */
+		}
+	}
+	/* Open an existing file */
+	else {
+#endif /* !_FS_READONLY */
+		if (res != FR_OK) LEAVE_FF(dj.fs, res);	/* Follow failed */
+		dir = dj.dir;
+		if (!dir || (dir[DIR_Attr] & AM_DIR))	/* It is a directory */
+			LEAVE_FF(dj.fs, FR_NO_FILE);
+#if !_FS_READONLY
+		if ((mode & FA_WRITE) && (dir[DIR_Attr] & AM_RDO)) /* R/O violation */
+			LEAVE_FF(dj.fs, FR_DENIED);
+	}
+	fp->dir_sect = dj.fs->winsect;		/* Pointer to the directory entry */
+	fp->dir_ptr = dj.dir;
+#endif
+	fp->flag = mode;					/* File access mode */
+	fp->org_clust =						/* File start cluster */
+		((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);
+	fp->fsize = LD_DWORD(dir+DIR_FileSize);	/* File size */
+	fp->fptr = 0; fp->csect = 255;		/* File pointer */
+	fp->dsect = 0;
+	fp->fs = dj.fs; fp->id = dj.fs->id;	/* Owner file system object of the file */
+
+	LEAVE_FF(dj.fs, FR_OK);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read File                                                             */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_read (
+	FIL *fp, 		/* Pointer to the file object */
+	void *buff,		/* Pointer to data buffer */
+	UINT btr,		/* Number of bytes to read */
+	UINT *br		/* Pointer to number of bytes read */
+)
+{
+	FRESULT res;
+	DWORD clst, sect, remain;
+	UINT rcnt, cc;
+	BYTE *rbuff = buff;
+
+
+	*br = 0;	/* Initialize bytes read */
+
+	res = validate(fp->fs, fp->id);					/* Check validity of the object */
+	if (res != FR_OK) LEAVE_FF(fp->fs, res);
+	if (fp->flag & FA__ERROR)						/* Check abort flag */
+		LEAVE_FF(fp->fs, FR_INT_ERR);
+	if (!(fp->flag & FA_READ)) 						/* Check access mode */
+		LEAVE_FF(fp->fs, FR_DENIED);
+	remain = fp->fsize - fp->fptr;
+	if (btr > remain) btr = (UINT)remain;			/* Truncate btr by remaining bytes */
+
+	for ( ;  btr;									/* Repeat until all data transferred */
+		rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) {
+		if ((fp->fptr % SS(fp->fs)) == 0) {			/* On the sector boundary? */
+			if (fp->csect >= fp->fs->csize) {		/* On the cluster boundary? */
+				clst = (fp->fptr == 0) ?			/* On the top of the file? */
+					fp->org_clust : get_fat(fp->fs, fp->curr_clust);
+				if (clst <= 1) ABORT(fp->fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+				fp->curr_clust = clst;				/* Update current cluster */
+				fp->csect = 0;						/* Reset sector offset in the cluster */
+			}
+			sect = clust2sect(fp->fs, fp->curr_clust);	/* Get current sector */
+			if (!sect) ABORT(fp->fs, FR_INT_ERR);
+			sect += fp->csect;
+			cc = btr / SS(fp->fs);					/* When remaining bytes >= sector size, */
+			if (cc) {								/* Read maximum contiguous sectors directly */
+				if (fp->csect + cc > fp->fs->csize)	/* Clip at cluster boundary */
+					cc = fp->fs->csize - fp->csect;
+				if (disk_read(fp->fs->drive, rbuff, sect, (BYTE)cc) != RES_OK)
+					ABORT(fp->fs, FR_DISK_ERR);
+#if !_FS_READONLY && _FS_MINIMIZE <= 2
+#if _FS_TINY
+				if (fp->fs->wflag && fp->fs->winsect - sect < cc)		/* Replace one of the read sectors with cached data if it contains a dirty sector */
+					mem_cpy(rbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), fp->fs->win, SS(fp->fs));
+#else
+				if ((fp->flag & FA__DIRTY) && fp->dsect - sect < cc)	/* Replace one of the read sectors with cached data if it contains a dirty sector */
+					mem_cpy(rbuff + ((fp->dsect - sect) * SS(fp->fs)), fp->buf, SS(fp->fs));
+#endif
+#endif
+				fp->csect += (BYTE)cc;				/* Next sector address in the cluster */
+				rcnt = SS(fp->fs) * cc;				/* Number of bytes transferred */
+				continue;
+			}
+#if !_FS_TINY
+#if !_FS_READONLY
+			if (fp->flag & FA__DIRTY) {			/* Write sector I/O buffer if needed */
+				if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)
+					ABORT(fp->fs, FR_DISK_ERR);
+				fp->flag &= ~FA__DIRTY;
+			}
+#endif
+			if (fp->dsect != sect) {			/* Fill sector buffer with file data */
+				if (disk_read(fp->fs->drive, fp->buf, sect, 1) != RES_OK)
+					ABORT(fp->fs, FR_DISK_ERR);
+			}
+#endif
+			fp->dsect = sect;
+			fp->csect++;							/* Next sector address in the cluster */
+		}
+		rcnt = SS(fp->fs) - (fp->fptr % SS(fp->fs));	/* Get partial sector data from sector buffer */
+		if (rcnt > btr) rcnt = btr;
+#if _FS_TINY
+		if (move_window(fp->fs, fp->dsect))			/* Move sector window */
+			ABORT(fp->fs, FR_DISK_ERR);
+		mem_cpy(rbuff, &fp->fs->win[fp->fptr % SS(fp->fs)], rcnt);	/* Pick partial sector */
+#else
+		mem_cpy(rbuff, &fp->buf[fp->fptr % SS(fp->fs)], rcnt);	/* Pick partial sector */
+#endif
+	}
+
+	LEAVE_FF(fp->fs, FR_OK);
+}
+
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Write File                                                            */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_write (
+	FIL *fp,			/* Pointer to the file object */
+	const void *buff,	/* Pointer to the data to be written */
+	UINT btw,			/* Number of bytes to write */
+	UINT *bw			/* Pointer to number of bytes written */
+)
+{
+	FRESULT res;
+	DWORD clst, sect;
+	UINT wcnt, cc;
+	const BYTE *wbuff = buff;
+
+
+	*bw = 0;	/* Initialize bytes written */
+
+	res = validate(fp->fs, fp->id);					/* Check validity of the object */
+	if (res != FR_OK) LEAVE_FF(fp->fs, res);
+	if (fp->flag & FA__ERROR)						/* Check abort flag */
+		LEAVE_FF(fp->fs, FR_INT_ERR);
+	if (!(fp->flag & FA_WRITE))						/* Check access mode */
+		LEAVE_FF(fp->fs, FR_DENIED);
+	if (fp->fsize + btw < fp->fsize) btw = 0;		/* File size cannot reach 4GB */
+
+	for ( ;  btw;									/* Repeat until all data transferred */
+		wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) {
+		if ((fp->fptr % SS(fp->fs)) == 0) {			/* On the sector boundary? */
+			if (fp->csect >= fp->fs->csize) {		/* On the cluster boundary? */
+				if (fp->fptr == 0) {				/* On the top of the file? */
+					clst = fp->org_clust;			/* Follow from the origin */
+					if (clst == 0)					/* When there is no cluster chain, */
+						fp->org_clust = clst = create_chain(fp->fs, 0);	/* Create a new cluster chain */
+				} else {							/* Middle or end of the file */
+					clst = create_chain(fp->fs, fp->curr_clust);			/* Follow or streach cluster chain */
+				}
+				if (clst == 0) break;				/* Could not allocate a new cluster (disk full) */
+				if (clst == 1) ABORT(fp->fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+				fp->curr_clust = clst;				/* Update current cluster */
+				fp->csect = 0;						/* Reset sector address in the cluster */
+			}
+#if _FS_TINY
+			if (fp->fs->winsect == fp->dsect && move_window(fp->fs, 0))	/* Write back data buffer prior to following direct transfer */
+				ABORT(fp->fs, FR_DISK_ERR);
+#else
+			if (fp->flag & FA__DIRTY) {		/* Write back data buffer prior to following direct transfer */
+				if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)
+					ABORT(fp->fs, FR_DISK_ERR);
+				fp->flag &= ~FA__DIRTY;
+			}
+#endif
+			sect = clust2sect(fp->fs, fp->curr_clust);	/* Get current sector */
+			if (!sect) ABORT(fp->fs, FR_INT_ERR);
+			sect += fp->csect;
+			cc = btw / SS(fp->fs);					/* When remaining bytes >= sector size, */
+			if (cc) {								/* Write maximum contiguous sectors directly */
+				if (fp->csect + cc > fp->fs->csize)	/* Clip at cluster boundary */
+					cc = fp->fs->csize - fp->csect;
+				if (disk_write(fp->fs->drive, wbuff, sect, (BYTE)cc) != RES_OK)
+					ABORT(fp->fs, FR_DISK_ERR);
+#if _FS_TINY
+				if (fp->fs->winsect - sect < cc) {	/* Refill sector cache if it gets dirty by the direct write */
+					mem_cpy(fp->fs->win, wbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), SS(fp->fs));
+					fp->fs->wflag = 0;
+				}
+#else
+				if (fp->dsect - sect < cc) {		/* Refill sector cache if it gets dirty by the direct write */
+					mem_cpy(fp->buf, wbuff + ((fp->dsect - sect) * SS(fp->fs)), SS(fp->fs));
+					fp->flag &= ~FA__DIRTY;
+				}
+#endif
+				fp->csect += (BYTE)cc;				/* Next sector address in the cluster */
+				wcnt = SS(fp->fs) * cc;				/* Number of bytes transferred */
+				continue;
+			}
+#if _FS_TINY
+			if (fp->fptr >= fp->fsize) {			/* Avoid silly buffer filling at growing edge */
+				if (move_window(fp->fs, 0)) ABORT(fp->fs, FR_DISK_ERR);
+				fp->fs->winsect = sect;
+			}
+#else
+			if (fp->dsect != sect) {				/* Fill sector buffer with file data */
+				if (fp->fptr < fp->fsize &&
+					disk_read(fp->fs->drive, fp->buf, sect, 1) != RES_OK)
+						ABORT(fp->fs, FR_DISK_ERR);
+			}
+#endif
+			fp->dsect = sect;
+			fp->csect++;							/* Next sector address in the cluster */
+		}
+		wcnt = SS(fp->fs) - (fp->fptr % SS(fp->fs));	/* Put partial sector into file I/O buffer */
+		if (wcnt > btw) wcnt = btw;
+#if _FS_TINY
+		if (move_window(fp->fs, fp->dsect))			/* Move sector window */
+			ABORT(fp->fs, FR_DISK_ERR);
+		mem_cpy(&fp->fs->win[fp->fptr % SS(fp->fs)], wbuff, wcnt);	/* Fit partial sector */
+		fp->fs->wflag = 1;
+#else
+		mem_cpy(&fp->buf[fp->fptr % SS(fp->fs)], wbuff, wcnt);	/* Fit partial sector */
+		fp->flag |= FA__DIRTY;
+#endif
+	}
+
+	if (fp->fptr > fp->fsize) fp->fsize = fp->fptr;	/* Update file size if needed */
+	fp->flag |= FA__WRITTEN;						/* Set file changed flag */
+
+	LEAVE_FF(fp->fs, FR_OK);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Synchronize the File Object                                           */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_sync (
+	FIL *fp		/* Pointer to the file object */
+)
+{
+	FRESULT res;
+	DWORD tim;
+	BYTE *dir;
+
+
+	res = validate(fp->fs, fp->id);		/* Check validity of the object */
+	if (res == FR_OK) {
+		if (fp->flag & FA__WRITTEN) {	/* Has the file been written? */
+#if !_FS_TINY	/* Write-back dirty buffer */
+			if (fp->flag & FA__DIRTY) {
+				if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)
+					LEAVE_FF(fp->fs, FR_DISK_ERR);
+				fp->flag &= ~FA__DIRTY;
+			}
+#endif
+			/* Update the directory entry */
+			res = move_window(fp->fs, fp->dir_sect);
+			if (res == FR_OK) {
+				dir = fp->dir_ptr;
+				dir[DIR_Attr] |= AM_ARC;					/* Set archive bit */
+				ST_DWORD(dir+DIR_FileSize, fp->fsize);		/* Update file size */
+				ST_WORD(dir+DIR_FstClusLO, fp->org_clust);	/* Update start cluster */
+				ST_WORD(dir+DIR_FstClusHI, fp->org_clust >> 16);
+				tim = get_fattime();			/* Updated time */
+				ST_DWORD(dir+DIR_WrtTime, tim);
+				fp->flag &= ~FA__WRITTEN;
+				fp->fs->wflag = 1;
+				res = sync(fp->fs);
+			}
+		}
+	}
+
+	LEAVE_FF(fp->fs, res);
+}
+
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Close File                                                            */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_close (
+	FIL *fp		/* Pointer to the file object to be closed */
+)
+{
+	FRESULT res;
+
+
+#if _FS_READONLY
+	res = validate(fp->fs, fp->id);
+	if (res == FR_OK) fp->fs = NULL;
+	LEAVE_FF(fp->fs, res);
+#else
+	res = f_sync(fp);
+	if (res == FR_OK) fp->fs = NULL;
+	return res;
+#endif
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Change Current Drive/Directory                                        */
+/*-----------------------------------------------------------------------*/
+
+#if _FS_RPATH
+
+FRESULT f_chdrive (
+	BYTE drv		/* Drive number */
+)
+{
+	if (drv >= _DRIVES) return FR_INVALID_DRIVE;
+
+	Drive = drv;
+
+	return FR_OK;
+}
+
+
+
+
+FRESULT f_chdir (
+	const XCHAR *path	/* Pointer to the directory path */
+)
+{
+	FRESULT res;
+	DIR dj;
+	NAMEBUF(sfn, lfn);
+	BYTE *dir;
+
+
+	res = chk_mounted(&path, &dj.fs, 0);
+	if (res == FR_OK) {
+		INITBUF(dj, sfn, lfn);
+		res = follow_path(&dj, path);		/* Follow the file path */
+		if (res == FR_OK) {					/* Follow completed */
+			dir = dj.dir;					/* Pointer to the entry */
+			if (!dir) {
+				dj.fs->cdir = 0;			/* No entry (root dir) */
+			} else {
+				if (dir[DIR_Attr] & AM_DIR)	/* Reached to the dir */
+					dj.fs->cdir = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);
+				else
+					res = FR_NO_PATH;		/* Could not reach the dir (it is a file) */
+			}
+		}
+		if (res == FR_NO_FILE) res = FR_NO_PATH;
+	}
+
+	LEAVE_FF(dj.fs, res);
+}
+
+#endif
+
+
+
+#if _FS_MINIMIZE <= 2
+/*-----------------------------------------------------------------------*/
+/* Seek File R/W Pointer                                                 */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_lseek (
+	FIL *fp,		/* Pointer to the file object */
+	DWORD ofs		/* File pointer from top of file */
+)
+{
+	FRESULT res;
+	DWORD clst, bcs, nsect, ifptr;
+
+
+	res = validate(fp->fs, fp->id);		/* Check validity of the object */
+	if (res != FR_OK) LEAVE_FF(fp->fs, res);
+	if (fp->flag & FA__ERROR)			/* Check abort flag */
+		LEAVE_FF(fp->fs, FR_INT_ERR);
+	if (ofs > fp->fsize					/* In read-only mode, clip offset with the file size */
+#if !_FS_READONLY
+		 && !(fp->flag & FA_WRITE)
+#endif
+		) ofs = fp->fsize;
+
+	ifptr = fp->fptr;
+	fp->fptr = nsect = 0; fp->csect = 255;
+	if (ofs > 0) {
+		bcs = (DWORD)fp->fs->csize * SS(fp->fs);	/* Cluster size (byte) */
+		if (ifptr > 0 &&
+			(ofs - 1) / bcs >= (ifptr - 1) / bcs) {	/* When seek to same or following cluster, */
+			fp->fptr = (ifptr - 1) & ~(bcs - 1);	/* start from the current cluster */
+			ofs -= fp->fptr;
+			clst = fp->curr_clust;
+		} else {									/* When seek to back cluster, */
+			clst = fp->org_clust;					/* start from the first cluster */
+#if !_FS_READONLY
+			if (clst == 0) {						/* If no cluster chain, create a new chain */
+				clst = create_chain(fp->fs, 0);
+				if (clst == 1) ABORT(fp->fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+				fp->org_clust = clst;
+			}
+#endif
+			fp->curr_clust = clst;
+		}
+		if (clst != 0) {
+			while (ofs > bcs) {						/* Cluster following loop */
+#if !_FS_READONLY
+				if (fp->flag & FA_WRITE) {			/* Check if in write mode or not */
+					clst = create_chain(fp->fs, clst);	/* Force streached if in write mode */
+					if (clst == 0) {				/* When disk gets full, clip file size */
+						ofs = bcs; break;
+					}
+				} else
+#endif
+					clst = get_fat(fp->fs, clst);	/* Follow cluster chain if not in write mode */
+				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+				if (clst <= 1 || clst >= fp->fs->max_clust) ABORT(fp->fs, FR_INT_ERR);
+				fp->curr_clust = clst;
+				fp->fptr += bcs;
+				ofs -= bcs;
+			}
+			fp->fptr += ofs;
+			fp->csect = (BYTE)(ofs / SS(fp->fs));	/* Sector offset in the cluster */
+			if (ofs % SS(fp->fs)) {
+				nsect = clust2sect(fp->fs, clst);	/* Current sector */
+				if (!nsect) ABORT(fp->fs, FR_INT_ERR);
+				nsect += fp->csect;
+				fp->csect++;
+			}
+		}
+	}
+	if (fp->fptr % SS(fp->fs) && nsect != fp->dsect) {
+#if !_FS_TINY
+#if !_FS_READONLY
+		if (fp->flag & FA__DIRTY) {			/* Write-back dirty buffer if needed */
+			if (disk_write(fp->fs->drive, fp->buf, fp->dsect, 1) != RES_OK)
+				ABORT(fp->fs, FR_DISK_ERR);
+			fp->flag &= ~FA__DIRTY;
+		}
+#endif
+		if (disk_read(fp->fs->drive, fp->buf, nsect, 1) != RES_OK)
+			ABORT(fp->fs, FR_DISK_ERR);
+#endif
+		fp->dsect = nsect;
+	}
+#if !_FS_READONLY
+	if (fp->fptr > fp->fsize) {			/* Set changed flag if the file size is extended */
+		fp->fsize = fp->fptr;
+		fp->flag |= FA__WRITTEN;
+	}
+#endif
+
+	LEAVE_FF(fp->fs, res);
+}
+
+
+
+
+#if _FS_MINIMIZE <= 1
+/*-----------------------------------------------------------------------*/
+/* Create a Directroy Object                                             */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_opendir (
+	DIR *dj,			/* Pointer to directory object to create */
+	const XCHAR *path	/* Pointer to the directory path */
+)
+{
+	FRESULT res;
+	NAMEBUF(sfn, lfn);
+	BYTE *dir;
+
+
+	res = chk_mounted(&path, &dj->fs, 0);
+	if (res == FR_OK) {
+		INITBUF((*dj), sfn, lfn);
+		res = follow_path(dj, path);			/* Follow the path to the directory */
+		if (res == FR_OK) {						/* Follow completed */
+			dir = dj->dir;
+			if (dir) {							/* It is not the root dir */
+				if (dir[DIR_Attr] & AM_DIR) {	/* The object is a directory */
+					dj->sclust = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);
+				} else {						/* The object is not a directory */
+					res = FR_NO_PATH;
+				}
+			}
+			if (res == FR_OK) {
+				dj->id = dj->fs->id;
+				res = dir_seek(dj, 0);			/* Rewind dir */
+			}
+		}
+		if (res == FR_NO_FILE) res = FR_NO_PATH;
+	}
+
+	LEAVE_FF(dj->fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Directory Entry in Sequense                                      */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_readdir (
+	DIR *dj,			/* Pointer to the open directory object */
+	FILINFO *fno		/* Pointer to file information to return */
+)
+{
+	FRESULT res;
+	NAMEBUF(sfn, lfn);
+
+
+	res = validate(dj->fs, dj->id);			/* Check validity of the object */
+	if (res == FR_OK) {
+		INITBUF((*dj), sfn, lfn);
+		if (!fno) {
+			res = dir_seek(dj, 0);
+		} else {
+			res = dir_read(dj);
+			if (res == FR_NO_FILE) {
+				dj->sect = 0;
+				res = FR_OK;
+			}
+			if (res == FR_OK) {				/* A valid entry is found */
+				get_fileinfo(dj, fno);		/* Get the object information */
+				res = dir_next(dj, FALSE);	/* Increment index for next */
+				if (res == FR_NO_FILE) {
+					dj->sect = 0;
+					res = FR_OK;
+				}
+			}
+		}
+	}
+
+	LEAVE_FF(dj->fs, res);
+}
+
+
+
+#if _FS_MINIMIZE == 0
+/*-----------------------------------------------------------------------*/
+/* Get File Status                                                       */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_stat (
+	const XCHAR *path,	/* Pointer to the file path */
+	FILINFO *fno		/* Pointer to file information to return */
+)
+{
+	FRESULT res;
+	DIR dj;
+	NAMEBUF(sfn, lfn);
+
+
+	res = chk_mounted(&path, &dj.fs, 0);
+	if (res == FR_OK) {
+		INITBUF(dj, sfn, lfn);
+		res = follow_path(&dj, path);	/* Follow the file path */
+		if (res == FR_OK) {				/* Follwo completed */
+			if (dj.dir)	/* Found an object */
+				get_fileinfo(&dj, fno);
+			else		/* It is root dir */
+				res = FR_INVALID_NAME;
+		}
+	}
+
+	LEAVE_FF(dj.fs, res);
+}
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Get Number of Free Clusters                                           */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_getfree (
+	const XCHAR *path,	/* Pointer to the logical drive number (root dir) */
+	DWORD *nclst,		/* Pointer to the variable to return number of free clusters */
+	FATFS **fatfs		/* Pointer to pointer to corresponding file system object to return */
+)
+{
+	FRESULT res;
+	DWORD n, clst, sect, stat;
+	UINT i;
+	BYTE fat, *p;
+
+
+	/* Get drive number */
+	res = chk_mounted(&path, fatfs, 0);
+	if (res != FR_OK) LEAVE_FF(*fatfs, res);
+
+	/* If number of free cluster is valid, return it without cluster scan. */
+	if ((*fatfs)->free_clust <= (*fatfs)->max_clust - 2) {
+		*nclst = (*fatfs)->free_clust;
+		LEAVE_FF(*fatfs, FR_OK);
+	}
+
+	/* Get number of free clusters */
+	fat = (*fatfs)->fs_type;
+	n = 0;
+	if (fat == FS_FAT12) {
+		clst = 2;
+		do {
+			stat = get_fat(*fatfs, clst);
+			if (stat == 0xFFFFFFFF) LEAVE_FF(*fatfs, FR_DISK_ERR);
+			if (stat == 1) LEAVE_FF(*fatfs, FR_INT_ERR);
+			if (stat == 0) n++;
+		} while (++clst < (*fatfs)->max_clust);
+	} else {
+		clst = (*fatfs)->max_clust;
+		sect = (*fatfs)->fatbase;
+		i = 0; p = 0;
+		do {
+			if (!i) {
+				res = move_window(*fatfs, sect++);
+				if (res != FR_OK)
+					LEAVE_FF(*fatfs, res);
+				p = (*fatfs)->win;
+				i = SS(*fatfs);
+			}
+			if (fat == FS_FAT16) {
+				if (LD_WORD(p) == 0) n++;
+				p += 2; i -= 2;
+			} else {
+				if ((LD_DWORD(p) & 0x0FFFFFFF) == 0) n++;
+				p += 4; i -= 4;
+			}
+		} while (--clst);
+	}
+	(*fatfs)->free_clust = n;
+	if (fat == FS_FAT32) (*fatfs)->fsi_flag = 1;
+	*nclst = n;
+
+	LEAVE_FF(*fatfs, FR_OK);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Truncate File                                                         */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_truncate (
+	FIL *fp		/* Pointer to the file object */
+)
+{
+	FRESULT res;
+	DWORD ncl;
+
+
+	res = validate(fp->fs, fp->id);		/* Check validity of the object */
+	if (res != FR_OK) LEAVE_FF(fp->fs, res);
+	if (fp->flag & FA__ERROR)			/* Check abort flag */
+		LEAVE_FF(fp->fs, FR_INT_ERR);
+	if (!(fp->flag & FA_WRITE))			/* Check access mode */
+		LEAVE_FF(fp->fs, FR_DENIED);
+
+	if (fp->fsize > fp->fptr) {
+		fp->fsize = fp->fptr;	/* Set file size to current R/W point */
+		fp->flag |= FA__WRITTEN;
+		if (fp->fptr == 0) {	/* When set file size to zero, remove entire cluster chain */
+			res = remove_chain(fp->fs, fp->org_clust);
+			fp->org_clust = 0;
+		} else {				/* When truncate a part of the file, remove remaining clusters */
+			ncl = get_fat(fp->fs, fp->curr_clust);
+			res = FR_OK;
+			if (ncl == 0xFFFFFFFF) res = FR_DISK_ERR;
+			if (ncl == 1) res = FR_INT_ERR;
+			if (res == FR_OK && ncl < fp->fs->max_clust) {
+				res = put_fat(fp->fs, fp->curr_clust, 0x0FFFFFFF);
+				if (res == FR_OK) res = remove_chain(fp->fs, ncl);
+			}
+		}
+	}
+	if (res != FR_OK) fp->flag |= FA__ERROR;
+
+	LEAVE_FF(fp->fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Delete a File or Directory                                            */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_unlink (
+	const XCHAR *path		/* Pointer to the file or directory path */
+)
+{
+	FRESULT res;
+	DIR dj, sdj;
+	NAMEBUF(sfn, lfn);
+	BYTE *dir;
+	DWORD dclst;
+
+
+	res = chk_mounted(&path, &dj.fs, 1);
+	if (res != FR_OK) LEAVE_FF(dj.fs, res);
+
+	INITBUF(dj, sfn, lfn);
+	res = follow_path(&dj, path);			/* Follow the file path */
+	if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))
+		res = FR_INVALID_NAME;
+	if (res != FR_OK) LEAVE_FF(dj.fs, res); /* Follow failed */
+
+	dir = dj.dir;
+	if (!dir)								/* Is it the root directory? */
+		LEAVE_FF(dj.fs, FR_INVALID_NAME);
+	if (dir[DIR_Attr] & AM_RDO)				/* Is it a R/O object? */
+		LEAVE_FF(dj.fs, FR_DENIED);
+	dclst = ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | LD_WORD(dir+DIR_FstClusLO);
+
+	if (dir[DIR_Attr] & AM_DIR) {			/* It is a sub-directory */
+		if (dclst < 2) LEAVE_FF(dj.fs, FR_INT_ERR);
+		mem_cpy(&sdj, &dj, sizeof(DIR));	/* Check if the sub-dir is empty or not */
+		sdj.sclust = dclst;
+		res = dir_seek(&sdj, 2);
+		if (res != FR_OK) LEAVE_FF(dj.fs, res);
+		res = dir_read(&sdj);
+		if (res == FR_OK) res = FR_DENIED;	/* Not empty sub-dir */
+		if (res != FR_NO_FILE) LEAVE_FF(dj.fs, res);
+	}
+
+	res = dir_remove(&dj);					/* Remove directory entry */
+	if (res == FR_OK) {
+		if (dclst)
+			res = remove_chain(dj.fs, dclst);	/* Remove the cluster chain */
+		if (res == FR_OK) res = sync(dj.fs);
+	}
+
+	LEAVE_FF(dj.fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Create a Directory                                                    */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_mkdir (
+	const XCHAR *path		/* Pointer to the directory path */
+)
+{
+	FRESULT res;
+	DIR dj;
+	NAMEBUF(sfn, lfn);
+	BYTE *dir, n;
+	DWORD dsect, dclst, pclst, tim;
+
+
+	res = chk_mounted(&path, &dj.fs, 1);
+	if (res != FR_OK) LEAVE_FF(dj.fs, res);
+
+	INITBUF(dj, sfn, lfn);
+	res = follow_path(&dj, path);			/* Follow the file path */
+	if (res == FR_OK) res = FR_EXIST;		/* Any file or directory is already existing */
+	if (_FS_RPATH && res == FR_NO_FILE && (dj.fn[NS] & NS_DOT))
+		res = FR_INVALID_NAME;
+	if (res != FR_NO_FILE)					/* Any error occured */
+		LEAVE_FF(dj.fs, res);
+
+	dclst = create_chain(dj.fs, 0);			/* Allocate a new cluster for new directory table */
+	res = FR_OK;
+	if (dclst == 0) res = FR_DENIED;
+	if (dclst == 1) res = FR_INT_ERR;
+	if (dclst == 0xFFFFFFFF) res = FR_DISK_ERR;
+	if (res == FR_OK)
+		res = move_window(dj.fs, 0);
+	if (res != FR_OK) LEAVE_FF(dj.fs, res);
+	dsect = clust2sect(dj.fs, dclst);
+
+	dir = dj.fs->win;						/* Initialize the new directory table */
+	mem_set(dir, 0, SS(dj.fs));
+	mem_set(dir+DIR_Name, ' ', 8+3);		/* Create "." entry */
+	dir[DIR_Name] = '.';
+	dir[DIR_Attr] = AM_DIR;
+	tim = get_fattime();
+	ST_DWORD(dir+DIR_WrtTime, tim);
+	ST_WORD(dir+DIR_FstClusLO, dclst);
+	ST_WORD(dir+DIR_FstClusHI, dclst >> 16);
+	mem_cpy(dir+32, dir, 32); 			/* Create ".." entry */
+	dir[33] = '.';
+	pclst = dj.sclust;
+	if (dj.fs->fs_type == FS_FAT32 && pclst == dj.fs->dirbase)
+		pclst = 0;
+	ST_WORD(dir+32+DIR_FstClusLO, pclst);
+	ST_WORD(dir+32+DIR_FstClusHI, pclst >> 16);
+	for (n = 0; n < dj.fs->csize; n++) {	/* Write dot entries and clear left sectors */
+		dj.fs->winsect = dsect++;
+		dj.fs->wflag = 1;
+		res = move_window(dj.fs, 0);
+		if (res) LEAVE_FF(dj.fs, res);
+		mem_set(dir, 0, SS(dj.fs));
+	}
+
+	res = dir_register(&dj);
+	if (res != FR_OK) {
+		remove_chain(dj.fs, dclst);
+	} else {
+		dir = dj.dir;
+		dir[DIR_Attr] = AM_DIR;					/* Attribute */
+		ST_DWORD(dir+DIR_WrtTime, tim);			/* Crated time */
+		ST_WORD(dir+DIR_FstClusLO, dclst);		/* Table start cluster */
+		ST_WORD(dir+DIR_FstClusHI, dclst >> 16);
+		dj.fs->wflag = 1;
+		res = sync(dj.fs);
+	}
+
+	LEAVE_FF(dj.fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Change File Attribute                                                 */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_chmod (
+	const XCHAR *path,	/* Pointer to the file path */
+	BYTE value,			/* Attribute bits */
+	BYTE mask			/* Attribute mask to change */
+)
+{
+	FRESULT res;
+	DIR dj;
+	NAMEBUF(sfn, lfn);
+	BYTE *dir;
+
+
+	res = chk_mounted(&path, &dj.fs, 1);
+	if (res == FR_OK) {
+		INITBUF(dj, sfn, lfn);
+		res = follow_path(&dj, path);		/* Follow the file path */
+		if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))
+			res = FR_INVALID_NAME;
+		if (res == FR_OK) {
+			dir = dj.dir;
+			if (!dir) {						/* Is it a root directory? */
+				res = FR_INVALID_NAME;
+			} else {						/* File or sub directory */
+				mask &= AM_RDO|AM_HID|AM_SYS|AM_ARC;	/* Valid attribute mask */
+				dir[DIR_Attr] = (value & mask) | (dir[DIR_Attr] & (BYTE)~mask);	/* Apply attribute change */
+				dj.fs->wflag = 1;
+				res = sync(dj.fs);
+			}
+		}
+	}
+
+	LEAVE_FF(dj.fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Change Timestamp                                                      */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_utime (
+	const XCHAR *path,	/* Pointer to the file/directory name */
+	const FILINFO *fno	/* Pointer to the timestamp to be set */
+)
+{
+	FRESULT res;
+	DIR dj;
+	NAMEBUF(sfn, lfn);
+	BYTE *dir;
+
+
+	res = chk_mounted(&path, &dj.fs, 1);
+	if (res == FR_OK) {
+		INITBUF(dj, sfn, lfn);
+		res = follow_path(&dj, path);	/* Follow the file path */
+		if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))
+			res = FR_INVALID_NAME;
+		if (res == FR_OK) {
+			dir = dj.dir;
+			if (!dir) {				/* Root directory */
+				res = FR_INVALID_NAME;
+			} else {				/* File or sub-directory */
+				ST_WORD(dir+DIR_WrtTime, fno->ftime);
+				ST_WORD(dir+DIR_WrtDate, fno->fdate);
+				dj.fs->wflag = 1;
+				res = sync(dj.fs);
+			}
+		}
+	}
+
+	LEAVE_FF(dj.fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Rename File/Directory                                                 */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_rename (
+	const XCHAR *path_old,	/* Pointer to the old name */
+	const XCHAR *path_new	/* Pointer to the new name */
+)
+{
+	FRESULT res;
+	DIR dj_old, dj_new;
+	NAMEBUF(sfn, lfn);
+	BYTE buf[21], *dir;
+	DWORD dw;
+
+
+	INITBUF(dj_old, sfn, lfn);
+	res = chk_mounted(&path_old, &dj_old.fs, 1);
+	if (res == FR_OK) {
+		dj_new.fs = dj_old.fs;
+		res = follow_path(&dj_old, path_old);	/* Check old object */
+		if (_FS_RPATH && res == FR_OK && (dj_old.fn[NS] & NS_DOT))
+			res = FR_INVALID_NAME;
+	}
+	if (res != FR_OK) LEAVE_FF(dj_old.fs, res);	/* The old object is not found */
+
+	if (!dj_old.dir) LEAVE_FF(dj_old.fs, FR_NO_FILE);	/* Is root dir? */
+	mem_cpy(buf, dj_old.dir+DIR_Attr, 21);		/* Save the object information */
+
+	mem_cpy(&dj_new, &dj_old, sizeof(DIR));
+	res = follow_path(&dj_new, path_new);		/* Check new object */
+	if (res == FR_OK) res = FR_EXIST;			/* The new object name is already existing */
+	if (res == FR_NO_FILE) { 					/* Is it a valid path and no name collision? */
+		res = dir_register(&dj_new);			/* Register the new object */
+		if (res == FR_OK) {
+			dir = dj_new.dir;					/* Copy object information into new entry */
+			mem_cpy(dir+13, buf+2, 19);
+			dir[DIR_Attr] = buf[0] | AM_ARC;
+			dj_old.fs->wflag = 1;
+			if (dir[DIR_Attr] & AM_DIR) {		/* Update .. entry in the directory if needed */
+				dw = clust2sect(dj_new.fs, (DWORD)LD_WORD(dir+DIR_FstClusHI) | LD_WORD(dir+DIR_FstClusLO));
+				if (!dw) {
+					res = FR_INT_ERR;
+				} else {
+					res = move_window(dj_new.fs, dw);
+					dir = dj_new.fs->win+32;
+					if (res == FR_OK && dir[1] == '.') {
+						dw = (dj_new.fs->fs_type == FS_FAT32 && dj_new.sclust == dj_new.fs->dirbase) ? 0 : dj_new.sclust;
+						ST_WORD(dir+DIR_FstClusLO, dw);
+						ST_WORD(dir+DIR_FstClusHI, dw >> 16);
+						dj_new.fs->wflag = 1;
+					}
+				}
+			}
+			if (res == FR_OK) {
+				res = dir_remove(&dj_old);			/* Remove old entry */
+				if (res == FR_OK)
+					res = sync(dj_old.fs);
+			}
+		}
+	}
+
+	LEAVE_FF(dj_old.fs, res);
+}
+
+#endif /* !_FS_READONLY */
+#endif /* _FS_MINIMIZE == 0 */
+#endif /* _FS_MINIMIZE <= 1 */
+#endif /* _FS_MINIMIZE <= 2 */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Forward data to the stream directly (Available on only _FS_TINY cfg)  */
+/*-----------------------------------------------------------------------*/
+#if _USE_FORWARD && _FS_TINY
+
+FRESULT f_forward (
+	FIL *fp, 						/* Pointer to the file object */
+	UINT (*func)(const BYTE*,UINT),	/* Pointer to the streaming function */
+	UINT btr,						/* Number of bytes to forward */
+	UINT *bf						/* Pointer to number of bytes forwarded */
+)
+{
+	FRESULT res;
+	DWORD remain, clst, sect;
+	UINT rcnt;
+
+
+	*bf = 0;
+
+	res = validate(fp->fs, fp->id);					/* Check validity of the object */
+	if (res != FR_OK) LEAVE_FF(fp->fs, res);
+	if (fp->flag & FA__ERROR)						/* Check error flag */
+		LEAVE_FF(fp->fs, FR_INT_ERR);
+	if (!(fp->flag & FA_READ))						/* Check access mode */
+		LEAVE_FF(fp->fs, FR_DENIED);
+
+	remain = fp->fsize - fp->fptr;
+	if (btr > remain) btr = (UINT)remain;			/* Truncate btr by remaining bytes */
+
+	for ( ;  btr && (*func)(NULL, 0);				/* Repeat until all data transferred or stream becomes busy */
+		fp->fptr += rcnt, *bf += rcnt, btr -= rcnt) {
+		if ((fp->fptr % SS(fp->fs)) == 0) {			/* On the sector boundary? */
+			if (fp->csect >= fp->fs->csize) {		/* On the cluster boundary? */
+				clst = (fp->fptr == 0) ?			/* On the top of the file? */
+					fp->org_clust : get_fat(fp->fs, fp->curr_clust);
+				if (clst <= 1) ABORT(fp->fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+				fp->curr_clust = clst;				/* Update current cluster */
+				fp->csect = 0;						/* Reset sector address in the cluster */
+			}
+			fp->csect++;							/* Next sector address in the cluster */
+		}
+		sect = clust2sect(fp->fs, fp->curr_clust);	/* Get current data sector */
+		if (!sect) ABORT(fp->fs, FR_INT_ERR);
+		sect += fp->csect - 1;
+		if (move_window(fp->fs, sect))				/* Move sector window */
+			ABORT(fp->fs, FR_DISK_ERR);
+		fp->dsect = sect;
+		rcnt = SS(fp->fs) - (WORD)(fp->fptr % SS(fp->fs));	/* Forward data from sector window */
+		if (rcnt > btr) rcnt = btr;
+		rcnt = (*func)(&fp->fs->win[(WORD)fp->fptr % SS(fp->fs)], rcnt);
+		if (!rcnt) ABORT(fp->fs, FR_INT_ERR);
+	}
+
+	LEAVE_FF(fp->fs, FR_OK);
+}
+#endif /* _USE_FORWARD */
+
+
+
+#if _USE_MKFS && !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Create File System on the Drive                                       */
+/*-----------------------------------------------------------------------*/
+#define N_ROOTDIR	512			/* Multiple of 32 and <= 2048 */
+#define N_FATS		1			/* 1 or 2 */
+#define MAX_SECTOR	131072000UL	/* Maximum partition size */
+#define MIN_SECTOR	2000UL		/* Minimum partition size */
+
+
+FRESULT f_mkfs (
+	BYTE drv,			/* Logical drive number */
+	BYTE partition,		/* Partitioning rule 0:FDISK, 1:SFD */
+	WORD allocsize		/* Allocation unit size [bytes] */
+)
+{
+	static const DWORD sstbl[] = { 2048000, 1024000, 512000, 256000, 128000, 64000, 32000, 16000, 8000, 4000,   0 };
+	static const WORD cstbl[] =  {   32768,   16384,   8192,   4096,   2048, 16384,  8192,  4096, 2048, 1024, 512 };
+	BYTE fmt, m, *tbl;
+	DWORD b_part, b_fat, b_dir, b_data;		/* Area offset (LBA) */
+	DWORD n_part, n_rsv, n_fat, n_dir;		/* Area size */
+	DWORD n_clst, d, n;
+	WORD as;
+	FATFS *fs;
+	DSTATUS stat;
+
+
+	/* Check validity of the parameters */
+	if (drv >= _DRIVES) return FR_INVALID_DRIVE;
+	if (partition >= 2) return FR_MKFS_ABORTED;
+
+	/* Check mounted drive and clear work area */
+	fs = FatFs[drv];
+	if (!fs) return FR_NOT_ENABLED;
+	fs->fs_type = 0;
+	drv = LD2PD(drv);
+
+	/* Get disk statics */
+	stat = disk_initialize(drv);
+	if (stat & STA_NOINIT) return FR_NOT_READY;
+	if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
+#if _MAX_SS != 512						/* Get disk sector size */
+	if (disk_ioctl(drv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK
+		|| SS(fs) > _MAX_SS)
+		return FR_MKFS_ABORTED;
+#endif
+	if (disk_ioctl(drv, GET_SECTOR_COUNT, &n_part) != RES_OK || n_part < MIN_SECTOR)
+		return FR_MKFS_ABORTED;
+	if (n_part > MAX_SECTOR) n_part = MAX_SECTOR;
+	b_part = (!partition) ? 63 : 0;		/* Boot sector */
+	n_part -= b_part;
+	for (d = 512; d <= 32768U && d != allocsize; d <<= 1) ;	/* Check validity of the allocation unit size */
+	if (d != allocsize) allocsize = 0;
+	if (!allocsize) {					/* Auto selection of cluster size */
+		d = n_part;
+		for (as = SS(fs); as > 512U; as >>= 1) d >>= 1;
+		for (n = 0; d < sstbl[n]; n++) ;
+		allocsize = cstbl[n];
+	}
+	if (allocsize < SS(fs)) allocsize = SS(fs);
+
+	allocsize /= SS(fs);		/* Number of sectors per cluster */
+
+	/* Pre-compute number of clusters and FAT type */
+	n_clst = n_part / allocsize;
+	fmt = FS_FAT12;
+	if (n_clst >= 0xFF5) fmt = FS_FAT16;
+	if (n_clst >= 0xFFF5) fmt = FS_FAT32;
+
+	/* Determine offset and size of FAT structure */
+	switch (fmt) {
+	case FS_FAT12:
+		n_fat = ((n_clst * 3 + 1) / 2 + 3 + SS(fs) - 1) / SS(fs);
+		n_rsv = 1 + partition;
+		n_dir = N_ROOTDIR * 32 / SS(fs);
+		break;
+	case FS_FAT16:
+		n_fat = ((n_clst * 2) + 4 + SS(fs) - 1) / SS(fs);
+		n_rsv = 1 + partition;
+		n_dir = N_ROOTDIR * 32 / SS(fs);
+		break;
+	default:
+		n_fat = ((n_clst * 4) + 8 + SS(fs) - 1) / SS(fs);
+		n_rsv = 33 - partition;
+		n_dir = 0;
+	}
+	b_fat = b_part + n_rsv;			/* FATs start sector */
+	b_dir = b_fat + n_fat * N_FATS;	/* Directory start sector */
+	b_data = b_dir + n_dir;			/* Data start sector */
+
+	/* Align data start sector to erase block boundary (for flash memory media) */
+	if (disk_ioctl(drv, GET_BLOCK_SIZE, &n) != RES_OK) return FR_MKFS_ABORTED;
+	n = (b_data + n - 1) & ~(n - 1);
+	n_fat += (n - b_data) / N_FATS;
+	/* b_dir and b_data are no longer used below */
+
+	/* Determine number of cluster and final check of validity of the FAT type */
+	n_clst = (n_part - n_rsv - n_fat * N_FATS - n_dir) / allocsize;
+	if (   (fmt == FS_FAT16 && n_clst < 0xFF5)
+		|| (fmt == FS_FAT32 && n_clst < 0xFFF5))
+		return FR_MKFS_ABORTED;
+
+	/* Create partition table if needed */
+	if (!partition) {
+		DWORD n_disk = b_part + n_part;
+
+		mem_set(fs->win, 0, SS(fs));
+		tbl = fs->win+MBR_Table;
+		ST_DWORD(tbl, 0x00010180);		/* Partition start in CHS */
+		if (n_disk < 63UL * 255 * 1024) {	/* Partition end in CHS */
+			n_disk = n_disk / 63 / 255;
+			tbl[7] = (BYTE)n_disk;
+			tbl[6] = (BYTE)((n_disk >> 2) | 63);
+		} else {
+			ST_WORD(&tbl[6], 0xFFFF);
+		}
+		tbl[5] = 254;
+		if (fmt != FS_FAT32)			/* System ID */
+			tbl[4] = (n_part < 0x10000) ? 0x04 : 0x06;
+		else
+			tbl[4] = 0x0c;
+		ST_DWORD(tbl+8, 63);			/* Partition start in LBA */
+		ST_DWORD(tbl+12, n_part);		/* Partition size in LBA */
+		ST_WORD(tbl+64, 0xAA55);		/* Signature */
+		if (disk_write(drv, fs->win, 0, 1) != RES_OK)
+			return FR_DISK_ERR;
+		partition = 0xF8;
+	} else {
+		partition = 0xF0;
+	}
+
+	/* Create boot record */
+	tbl = fs->win;								/* Clear buffer */
+	mem_set(tbl, 0, SS(fs));
+	ST_DWORD(tbl+BS_jmpBoot, 0x90FEEB);			/* Boot code (jmp $, nop) */
+	ST_WORD(tbl+BPB_BytsPerSec, SS(fs));		/* Sector size */
+	tbl[BPB_SecPerClus] = (BYTE)allocsize;		/* Sectors per cluster */
+	ST_WORD(tbl+BPB_RsvdSecCnt, n_rsv);			/* Reserved sectors */
+	tbl[BPB_NumFATs] = N_FATS;					/* Number of FATs */
+	ST_WORD(tbl+BPB_RootEntCnt, SS(fs) / 32 * n_dir); /* Number of rootdir entries */
+	if (n_part < 0x10000) {						/* Number of total sectors */
+		ST_WORD(tbl+BPB_TotSec16, n_part);
+	} else {
+		ST_DWORD(tbl+BPB_TotSec32, n_part);
+	}
+	tbl[BPB_Media] = partition;					/* Media descripter */
+	ST_WORD(tbl+BPB_SecPerTrk, 63);				/* Number of sectors per track */
+	ST_WORD(tbl+BPB_NumHeads, 255);				/* Number of heads */
+	ST_DWORD(tbl+BPB_HiddSec, b_part);			/* Hidden sectors */
+	n = get_fattime();							/* Use current time as a VSN */
+	if (fmt != FS_FAT32) {
+		ST_DWORD(tbl+BS_VolID, n);				/* Volume serial number */
+		ST_WORD(tbl+BPB_FATSz16, n_fat);		/* Number of secters per FAT */
+		tbl[BS_DrvNum] = 0x80;					/* Drive number */
+		tbl[BS_BootSig] = 0x29;					/* Extended boot signature */
+		mem_cpy(tbl+BS_VolLab, "NO NAME    FAT     ", 19);	/* Volume lavel, FAT signature */
+	} else {
+		ST_DWORD(tbl+BS_VolID32, n);			/* Volume serial number */
+		ST_DWORD(tbl+BPB_FATSz32, n_fat);		/* Number of secters per FAT */
+		ST_DWORD(tbl+BPB_RootClus, 2);			/* Root directory cluster (2) */
+		ST_WORD(tbl+BPB_FSInfo, 1);				/* FSInfo record offset (bs+1) */
+		ST_WORD(tbl+BPB_BkBootSec, 6);			/* Backup boot record offset (bs+6) */
+		tbl[BS_DrvNum32] = 0x80;				/* Drive number */
+		tbl[BS_BootSig32] = 0x29;				/* Extended boot signature */
+		mem_cpy(tbl+BS_VolLab32, "NO NAME    FAT32   ", 19);	/* Volume lavel, FAT signature */
+	}
+	ST_WORD(tbl+BS_55AA, 0xAA55);				/* Signature */
+	if (SS(fs) > 512U) {
+		ST_WORD(tbl+SS(fs)-2, 0xAA55);
+	}
+	if (disk_write(drv, tbl, b_part+0, 1) != RES_OK)
+		return FR_DISK_ERR;
+	if (fmt == FS_FAT32)
+		disk_write(drv, tbl, b_part+6, 1);
+
+	/* Initialize FAT area */
+	for (m = 0; m < N_FATS; m++) {
+		mem_set(tbl, 0, SS(fs));		/* 1st sector of the FAT  */
+		if (fmt != FS_FAT32) {
+			n = (fmt == FS_FAT12) ? 0x00FFFF00 : 0xFFFFFF00;
+			n |= partition;
+			ST_DWORD(tbl, n);				/* Reserve cluster #0-1 (FAT12/16) */
+		} else {
+			ST_DWORD(tbl+0, 0xFFFFFFF8);	/* Reserve cluster #0-1 (FAT32) */
+			ST_DWORD(tbl+4, 0xFFFFFFFF);
+			ST_DWORD(tbl+8, 0x0FFFFFFF);	/* Reserve cluster #2 for root dir */
+		}
+		if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)
+			return FR_DISK_ERR;
+		mem_set(tbl, 0, SS(fs));		/* Following FAT entries are filled by zero */
+		for (n = 1; n < n_fat; n++) {
+			if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)
+				return FR_DISK_ERR;
+		}
+	}
+
+	/* Initialize Root directory */
+	m = (BYTE)((fmt == FS_FAT32) ? allocsize : n_dir);
+	do {
+		if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)
+			return FR_DISK_ERR;
+	} while (--m);
+
+	/* Create FSInfo record if needed */
+	if (fmt == FS_FAT32) {
+		ST_WORD(tbl+BS_55AA, 0xAA55);
+		ST_DWORD(tbl+FSI_LeadSig, 0x41615252);
+		ST_DWORD(tbl+FSI_StrucSig, 0x61417272);
+		ST_DWORD(tbl+FSI_Free_Count, n_clst - 1);
+		ST_DWORD(tbl+FSI_Nxt_Free, 0xFFFFFFFF);
+		disk_write(drv, tbl, b_part+1, 1);
+		disk_write(drv, tbl, b_part+7, 1);
+	}
+
+	return (disk_ioctl(drv, CTRL_SYNC, (void*)NULL) == RES_OK) ? FR_OK : FR_DISK_ERR;
+}
+
+#endif /* _USE_MKFS && !_FS_READONLY */
+
+
+
+
+#if _USE_STRFUNC
+/*-----------------------------------------------------------------------*/
+/* Get a string from the file                                            */
+/*-----------------------------------------------------------------------*/
+char* f_gets (
+	char* buff,	/* Pointer to the string buffer to read */
+	int len,	/* Size of string buffer */
+	FIL* fil	/* Pointer to the file object */
+)
+{
+	int i = 0;
+	char *p = buff;
+	UINT rc;
+
+
+	while (i < len - 1) {			/* Read bytes until buffer gets filled */
+		f_read(fil, p, 1, &rc);
+		if (rc != 1) break;			/* Break when no data to read */
+#if _USE_STRFUNC >= 2
+		if (*p == '\r') continue;	/* Strip '\r' */
+#endif
+		i++;
+		if (*p++ == '\n') break;	/* Break when reached end of line */
+	}
+	*p = 0;
+	return i ? buff : NULL;			/* When no data read (eof or error), return with error. */
+}
+
+
+
+#if !_FS_READONLY
+#include <stdarg.h>
+/*-----------------------------------------------------------------------*/
+/* Put a character to the file                                           */
+/*-----------------------------------------------------------------------*/
+int f_putc (
+	int chr,	/* A character to be output */
+	FIL* fil	/* Ponter to the file object */
+)
+{
+	UINT bw;
+	char c;
+
+
+#if _USE_STRFUNC >= 2
+	if (chr == '\n') f_putc ('\r', fil);	/* LF -> CRLF conversion */
+#endif
+	if (!fil) {	/* Special value may be used to switch the destination to any other device */
+	/*	put_console(chr);	*/
+		return chr;
+	}
+	c = (char)chr;
+	f_write(fil, &c, 1, &bw);	/* Write a byte to the file */
+	return bw ? chr : EOF;		/* Return the result */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Put a string to the file                                              */
+/*-----------------------------------------------------------------------*/
+int f_puts (
+	const char* str,	/* Pointer to the string to be output */
+	FIL* fil			/* Pointer to the file object */
+)
+{
+	int n;
+
+
+	for (n = 0; *str; str++, n++) {
+		if (f_putc(*str, fil) == EOF) return EOF;
+	}
+	return n;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Put a formatted string to the file                                    */
+/*-----------------------------------------------------------------------*/
+int f_printf (
+	FIL* fil,			/* Pointer to the file object */
+	const char* str,	/* Pointer to the format string */
+	...					/* Optional arguments... */
+)
+{
+	va_list arp;
+	UCHAR c, f, r;
+	ULONG val;
+	char s[16];
+	int i, w, res, cc;
+
+
+	va_start(arp, str);
+
+	for (cc = res = 0; cc != EOF; res += cc) {
+		c = *str++;
+		if (c == 0) break;			/* End of string */
+		if (c != '%') {				/* Non escape cahracter */
+			cc = f_putc(c, fil);
+			if (cc != EOF) cc = 1;
+			continue;
+		}
+		w = f = 0;
+		c = *str++;
+		if (c == '0') {				/* Flag: '0' padding */
+			f = 1; c = *str++;
+		}
+		while (c >= '0' && c <= '9') {	/* Precision */
+			w = w * 10 + (c - '0');
+			c = *str++;
+		}
+		if (c == 'l') {				/* Prefix: Size is long int */
+			f |= 2; c = *str++;
+		}
+		if (c == 's') {				/* Type is string */
+			cc = f_puts(va_arg(arp, char*), fil);
+			continue;
+		}
+		if (c == 'c') {				/* Type is character */
+			cc = f_putc(va_arg(arp, int), fil);
+			if (cc != EOF) cc = 1;
+			continue;
+		}
+		r = 0;
+		if (c == 'd') r = 10;		/* Type is signed decimal */
+		if (c == 'u') r = 10;		/* Type is unsigned decimal */
+		if (c == 'X') r = 16;		/* Type is unsigned hexdecimal */
+		if (r == 0) break;			/* Unknown type */
+		if (f & 2) {				/* Get the value */
+			val = (ULONG)va_arg(arp, long);
+		} else {
+			val = (c == 'd') ? (ULONG)(long)va_arg(arp, int) : (ULONG)va_arg(arp, unsigned int);
+		}
+		/* Put numeral string */
+		if (c == 'd') {
+			if (val & 0x80000000) {
+				val = 0 - val;
+				f |= 4;
+			}
+		}
+		i = sizeof(s) - 1; s[i] = 0;
+		do {
+			c = (UCHAR)(val % r + '0');
+			if (c > '9') c += 7;
+			s[--i] = c;
+			val /= r;
+		} while (i && val);
+		if (i && (f & 4)) s[--i] = '-';
+		w = sizeof(s) - 1 - w;
+		while (i && i > w) s[--i] = (f & 1) ? '0' : ' ';
+		cc = f_puts(&s[i], fil);
+	}
+
+	va_end(arp);
+	return (cc == EOF) ? cc : res;
+}
+
+#endif /* !_FS_READONLY */
+#endif /* _USE_STRFUNC */
diff --git a/Projects/Webserver/Lib/FATFs/ff.h b/Projects/Webserver/Lib/FATFs/ff.h
index 41e136ee5..69bfd3109 100644
--- a/Projects/Webserver/Lib/FATFs/ff.h
+++ b/Projects/Webserver/Lib/FATFs/ff.h
@@ -1,596 +1,596 @@
-/*---------------------------------------------------------------------------/

-/  FatFs - FAT file system module include file  R0.07e       (C)ChaN, 2010

-/----------------------------------------------------------------------------/

-/ FatFs module is a generic FAT file system module for small embedded systems.

-/ This is a free software that opened for education, research and commercial

-/ developments under license policy of following trems.

-/

-/  Copyright (C) 2010, ChaN, all right reserved.

-/

-/ * The FatFs module is a free software and there is NO WARRANTY.

-/ * No restriction on use. You can use, modify and redistribute it for

-/   personal, non-profit or commercial product UNDER YOUR RESPONSIBILITY.

-/ * Redistributions of source code must retain the above copyright notice.

-/----------------------------------------------------------------------------*/

-

-#ifndef _FATFS

-#define _FATFS	0x007E

-

-#include "integer.h"	/* Basic integer types */

-#include "ffconf.h"		/* FatFs configuration options */

-

-#if _FATFS != _FFCONFIG

-#error Wrong configuration file (ffconf.h).

-#endif

-

-

-/* DBCS code ranges and SBCS extend char conversion table */

-

-#if _CODE_PAGE == 932	/* Japanese Shift-JIS */

-#define _DF1S	0x81	/* DBC 1st byte range 1 start */

-#define _DF1E	0x9F	/* DBC 1st byte range 1 end */

-#define _DF2S	0xE0	/* DBC 1st byte range 2 start */

-#define _DF2E	0xFC	/* DBC 1st byte range 2 end */

-#define _DS1S	0x40	/* DBC 2nd byte range 1 start */

-#define _DS1E	0x7E	/* DBC 2nd byte range 1 end */

-#define _DS2S	0x80	/* DBC 2nd byte range 2 start */

-#define _DS2E	0xFC	/* DBC 2nd byte range 2 end */

-

-#elif _CODE_PAGE == 936	/* Simplified Chinese GBK */

-#define _DF1S	0x81

-#define _DF1E	0xFE

-#define _DS1S	0x40

-#define _DS1E	0x7E

-#define _DS2S	0x80

-#define _DS2E	0xFE

-

-#elif _CODE_PAGE == 949	/* Korean */

-#define _DF1S	0x81

-#define _DF1E	0xFE

-#define _DS1S	0x41

-#define _DS1E	0x5A

-#define _DS2S	0x61

-#define _DS2E	0x7A

-#define _DS3S	0x81

-#define _DS3E	0xFE

-

-#elif _CODE_PAGE == 950	/* Traditional Chinese Big5 */

-#define _DF1S	0x81

-#define _DF1E	0xFE

-#define _DS1S	0x40

-#define _DS1E	0x7E

-#define _DS2S	0xA1

-#define _DS2E	0xFE

-

-#elif _CODE_PAGE == 437	/* U.S. (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x9A,0x90,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x49,0x49,0x49,0x8E,0x8F,0x90,0x92,0x92,0x4F,0x99,0x4F,0x55,0x55,0x59,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

-				0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 720	/* Arabic (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x45,0x41,0x84,0x41,0x86,0x43,0x45,0x45,0x45,0x49,0x49,0x8D,0x8E,0x8F,0x90,0x92,0x92,0x93,0x94,0x95,0x49,0x49,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

-				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 737	/* Greek (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x92,0x92,0x93,0x94,0x95,0x96,0x97,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87, \

-				0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0xAA,0x92,0x93,0x94,0x95,0x96,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0x97,0xEA,0xEB,0xEC,0xE4,0xED,0xEE,0xE7,0xE8,0xF1,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 775	/* Baltic (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x9A,0x91,0xA0,0x8E,0x95,0x8F,0x80,0xAD,0xED,0x8A,0x8A,0xA1,0x8D,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0x95,0x96,0x97,0x97,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \

-				0xA0,0xA1,0xE0,0xA3,0xA3,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xB5,0xB6,0xB7,0xB8,0xBD,0xBE,0xC6,0xC7,0xA5,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE3,0xE8,0xE8,0xEA,0xEA,0xEE,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 850	/* Multilingual Latin 1 (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0xDE,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x59,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \

-				0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE7,0xE9,0xEA,0xEB,0xED,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 852	/* Latin 2 (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xDE,0x8F,0x80,0x9D,0xD3,0x8A,0x8A,0xD7,0x8D,0x8E,0x8F,0x90,0x91,0x91,0xE2,0x99,0x95,0x95,0x97,0x97,0x99,0x9A,0x9B,0x9B,0x9D,0x9E,0x9F, \

-				0xB5,0xD6,0xE0,0xE9,0xA4,0xA4,0xA6,0xA6,0xA8,0xA8,0xAA,0x8D,0xAC,0xB8,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBD,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC6,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD1,0xD1,0xD2,0xD3,0xD2,0xD5,0xD6,0xD7,0xB7,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xE0,0xE1,0xE2,0xE3,0xE3,0xD5,0xE6,0xE6,0xE8,0xE9,0xE8,0xEB,0xED,0xED,0xDD,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xEB,0xFC,0xFC,0xFE,0xFF}

-

-#elif _CODE_PAGE == 855	/* Cyrillic (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x81,0x81,0x83,0x83,0x85,0x85,0x87,0x87,0x89,0x89,0x8B,0x8B,0x8D,0x8D,0x8F,0x8F,0x91,0x91,0x93,0x93,0x95,0x95,0x97,0x97,0x99,0x99,0x9B,0x9B,0x9D,0x9D,0x9F,0x9F, \

-				0xA1,0xA1,0xA3,0xA3,0xA5,0xA5,0xA7,0xA7,0xA9,0xA9,0xAB,0xAB,0xAD,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB6,0xB6,0xB8,0xB8,0xB9,0xBA,0xBB,0xBC,0xBE,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD1,0xD1,0xD3,0xD3,0xD5,0xD5,0xD7,0xD7,0xDD,0xD9,0xDA,0xDB,0xDC,0xDD,0xE0,0xDF, \

-				0xE0,0xE2,0xE2,0xE4,0xE4,0xE6,0xE6,0xE8,0xE8,0xEA,0xEA,0xEC,0xEC,0xEE,0xEE,0xEF,0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF8,0xFA,0xFA,0xFC,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 857	/* Turkish (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0x98,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x98,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9E, \

-				0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA6,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xDE,0x59,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 858	/* Multilingual Latin 1 + Euro (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0xDE,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x59,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \

-				0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD1,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE7,0xE9,0xEA,0xEB,0xED,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 862	/* Hebrew (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

-				0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 866	/* Russian (OEM) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

-				0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0x90,0x91,0x92,0x93,0x9d,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xF0,0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 874	/* Thai (OEM, Windows) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

-				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 1250 /* Central Europe (Windows) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x8D,0x8E,0x8F, \

-				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xA3,0xB4,0xB5,0xB6,0xB7,0xB8,0xA5,0xAA,0xBB,0xBC,0xBD,0xBC,0xAF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xFF}

-

-#elif _CODE_PAGE == 1251 /* Cyrillic (Windows) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x82,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x80,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x8D,0x8E,0x8F, \

-				0xA0,0xA2,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB2,0xA5,0xB5,0xB6,0xB7,0xA8,0xB9,0xAA,0xBB,0xA3,0xBD,0xBD,0xAF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF}

-

-#elif _CODE_PAGE == 1252 /* Latin 1 (Windows) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xAd,0x9B,0x8C,0x9D,0xAE,0x9F, \

-				0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x9F}

-

-#elif _CODE_PAGE == 1253 /* Greek (Windows) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

-				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xA2,0xB8,0xB9,0xBA, \

-				0xE0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xF2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xFB,0xBC,0xFD,0xBF,0xFF}

-

-#elif _CODE_PAGE == 1254 /* Turkish (Windows) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x9D,0x9E,0x9F, \

-				0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x9F}

-

-#elif _CODE_PAGE == 1255 /* Hebrew (Windows) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

-				0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 1256 /* Arabic (Windows) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x8C,0x9D,0x9E,0x9F, \

-				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0x41,0xE1,0x41,0xE3,0xE4,0xE5,0xE6,0x43,0x45,0x45,0x45,0x45,0xEC,0xED,0x49,0x49,0xF0,0xF1,0xF2,0xF3,0x4F,0xF5,0xF6,0xF7,0xF8,0x55,0xFA,0x55,0x55,0xFD,0xFE,0xFF}

-

-#elif _CODE_PAGE == 1257 /* Baltic (Windows) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

-				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xA8,0xB9,0xAA,0xBB,0xBC,0xBD,0xBE,0xAF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xFF}

-

-#elif _CODE_PAGE == 1258 /* Vietnam (OEM, Windows) */

-#define _DF1S	0

-#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0xAC,0x9D,0x9E,0x9F, \

-				0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

-				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xEC,0xCD,0xCE,0xCF,0xD0,0xD1,0xF2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xFE,0x9F}

-

-#elif _CODE_PAGE == 1	/* ASCII (for only non-LFN cfg) */

-#define _DF1S	0

-

-#else

-#error Unknown code page

-

-#endif

-

-

-

-/* Character code support macros */

-

-#define IsUpper(c)	(((c)>='A')&&((c)<='Z'))

-#define IsLower(c)	(((c)>='a')&&((c)<='z'))

-

-#if _DF1S		/* DBCS configuration */

-

-#ifdef _DF2S	/* Two 1st byte areas */

-#define IsDBCS1(c)	(((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E) || ((BYTE)(c) >= _DF2S && (BYTE)(c) <= _DF2E))

-#else			/* One 1st byte area */

-#define IsDBCS1(c)	((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E)

-#endif

-

-#ifdef _DS3S	/* Three 2nd byte areas */

-#define IsDBCS2(c)	(((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E) || ((BYTE)(c) >= _DS3S && (BYTE)(c) <= _DS3E))

-#else			/* Two 2nd byte areas */

-#define IsDBCS2(c)	(((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E))

-#endif

-

-#else			/* SBCS configuration */

-

-#define IsDBCS1(c)	0

-#define IsDBCS2(c)	0

-

-#endif /* _DF1S */

-

-

-

-/* Definitions corresponds to multi partition */

-

-#if _MULTI_PARTITION		/* Multiple partition configuration */

-

-typedef struct _PARTITION {

-	BYTE pd;	/* Physical drive# */

-	BYTE pt;	/* Partition # (0-3) */

-} PARTITION;

-

-extern

-const PARTITION Drives[];			/* Logical drive# to physical location conversion table */

-#define LD2PD(drv) (Drives[drv].pd)	/* Get physical drive# */

-#define LD2PT(drv) (Drives[drv].pt)	/* Get partition# */

-

-#else						/* Single partition configuration */

-

-#define LD2PD(drv) (drv)	/* Physical drive# is equal to the logical drive# */

-#define LD2PT(drv) 0		/* Always mounts the 1st partition */

-

-#endif

-

-

-

-/* Definitions corresponds to multiple sector size */

-

-#if _MAX_SS == 512		/* Single sector size */

-#define	SS(fs)	512U

-

-#elif _MAX_SS == 1024 || _MAX_SS == 2048 || _MAX_SS == 4096	/* Multiple sector size */

-#define	SS(fs)	((fs)->s_size)

-

-#else

-#error Sector size must be 512, 1024, 2048 or 4096.

-

-#endif

-

-

-

-/* Type of file name on FatFs API */

-

-#if _LFN_UNICODE && _USE_LFN

-typedef WCHAR XCHAR;	/* Unicode */

-#else

-typedef char XCHAR;		/* SBCS, DBCS */

-#endif

-

-

-

-/* File system object structure */

-

-typedef struct _FATFS_ {

-	BYTE	fs_type;	/* FAT sub type */

-	BYTE	drive;		/* Physical drive number */

-	BYTE	csize;		/* Number of sectors per cluster */

-	BYTE	n_fats;		/* Number of FAT copies */

-	BYTE	wflag;		/* win[] dirty flag (1:must be written back) */

-	BYTE	fsi_flag;	/* fsinfo dirty flag (1:must be written back) */

-	WORD	id;			/* File system mount ID */

-	WORD	n_rootdir;	/* Number of root directory entries (0 on FAT32) */

-#if _FS_REENTRANT

-	_SYNC_t	sobj;		/* Identifier of sync object */

-#endif

-#if _MAX_SS != 512

-	WORD	s_size;		/* Sector size */

-#endif

-#if !_FS_READONLY

-	DWORD	last_clust;	/* Last allocated cluster */

-	DWORD	free_clust;	/* Number of free clusters */

-	DWORD	fsi_sector;	/* fsinfo sector */

-#endif

-#if _FS_RPATH

-	DWORD	cdir;		/* Current directory (0:root)*/

-#endif

-	DWORD	sects_fat;	/* Sectors per fat */

-	DWORD	max_clust;	/* Maximum cluster# + 1. Number of clusters is max_clust - 2 */

-	DWORD	fatbase;	/* FAT start sector */

-	DWORD	dirbase;	/* Root directory start sector (Cluster# on FAT32) */

-	DWORD	database;	/* Data start sector */

-	DWORD	winsect;	/* Current sector appearing in the win[] */

-	BYTE	win[_MAX_SS];/* Disk access window for Directory/FAT */

-} FATFS;

-

-

-

-/* Directory object structure */

-

-typedef struct _DIR_ {

-	FATFS*	fs;			/* Pointer to the owner file system object */

-	WORD	id;			/* Owner file system mount ID */

-	WORD	index;		/* Current read/write index number */

-	DWORD	sclust;		/* Table start cluster (0:Static table) */

-	DWORD	clust;		/* Current cluster */

-	DWORD	sect;		/* Current sector */

-	BYTE*	dir;		/* Pointer to the current SFN entry in the win[] */

-	BYTE*	fn;			/* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */

-#if _USE_LFN

-	WCHAR*	lfn;		/* Pointer to the LFN working buffer */

-	WORD	lfn_idx;	/* Last matched LFN index number (0xFFFF:No LFN) */

-#endif

-} DIR;

-

-

-

-/* File object structure */

-

-typedef struct _FIL_ {

-	FATFS*	fs;			/* Pointer to the owner file system object */

-	WORD	id;			/* Owner file system mount ID */

-	BYTE	flag;		/* File status flags */

-	BYTE	csect;		/* Sector address in the cluster */

-	DWORD	fptr;		/* File R/W pointer */

-	DWORD	fsize;		/* File size */

-	DWORD	org_clust;	/* File start cluster */

-	DWORD	curr_clust;	/* Current cluster */

-	DWORD	dsect;		/* Current data sector */

-#if !_FS_READONLY

-	DWORD	dir_sect;	/* Sector containing the directory entry */

-	BYTE*	dir_ptr;	/* Ponter to the directory entry in the window */

-#endif

-#if !_FS_TINY

-	BYTE	buf[_MAX_SS];/* File R/W buffer */

-#endif

-} FIL;

-

-

-

-/* File status structure */

-

-typedef struct _FILINFO_ {

-	DWORD	fsize;		/* File size */

-	WORD	fdate;		/* Last modified date */

-	WORD	ftime;		/* Last modified time */

-	BYTE	fattrib;	/* Attribute */

-	char	fname[13];	/* Short file name (8.3 format) */

-#if _USE_LFN

-	XCHAR*	lfname;		/* Pointer to the LFN buffer */

-	int 	lfsize;		/* Size of LFN buffer [chrs] */

-#endif

-} FILINFO;

-

-

-

-/* File function return code (FRESULT) */

-

-typedef enum {

-	FR_OK = 0,			/* 0 */

-	FR_DISK_ERR,		/* 1 */

-	FR_INT_ERR,			/* 2 */

-	FR_NOT_READY,		/* 3 */

-	FR_NO_FILE,			/* 4 */

-	FR_NO_PATH,			/* 5 */

-	FR_INVALID_NAME,	/* 6 */

-	FR_DENIED,			/* 7 */

-	FR_EXIST,			/* 8 */

-	FR_INVALID_OBJECT,	/* 9 */

-	FR_WRITE_PROTECTED,	/* 10 */

-	FR_INVALID_DRIVE,	/* 11 */

-	FR_NOT_ENABLED,		/* 12 */

-	FR_NO_FILESYSTEM,	/* 13 */

-	FR_MKFS_ABORTED,	/* 14 */

-	FR_TIMEOUT			/* 15 */

-} FRESULT;

-

-

-

-/*--------------------------------------------------------------*/

-/* FatFs module application interface                           */

-

-FRESULT f_mount (BYTE, FATFS*);						/* Mount/Unmount a logical drive */

-FRESULT f_open (FIL*, const XCHAR*, BYTE);			/* Open or create a file */

-FRESULT f_read (FIL*, void*, UINT, UINT*);			/* Read data from a file */

-FRESULT f_write (FIL*, const void*, UINT, UINT*);	/* Write data to a file */

-FRESULT f_lseek (FIL*, DWORD);						/* Move file pointer of a file object */

-FRESULT f_close (FIL*);								/* Close an open file object */

-FRESULT f_opendir (DIR*, const XCHAR*);				/* Open an existing directory */

-FRESULT f_readdir (DIR*, FILINFO*);					/* Read a directory item */

-FRESULT f_stat (const XCHAR*, FILINFO*);			/* Get file status */

-FRESULT f_getfree (const XCHAR*, DWORD*, FATFS**);	/* Get number of free clusters on the drive */

-FRESULT f_truncate (FIL*);							/* Truncate file */

-FRESULT f_sync (FIL*);								/* Flush cached data of a writing file */

-FRESULT f_unlink (const XCHAR*);					/* Delete an existing file or directory */

-FRESULT	f_mkdir (const XCHAR*);						/* Create a new directory */

-FRESULT f_chmod (const XCHAR*, BYTE, BYTE);			/* Change attriburte of the file/dir */

-FRESULT f_utime (const XCHAR*, const FILINFO*);		/* Change timestamp of the file/dir */

-FRESULT f_rename (const XCHAR*, const XCHAR*);		/* Rename/Move a file or directory */

-FRESULT f_forward (FIL*, UINT(*)(const BYTE*,UINT), UINT, UINT*);	/* Forward data to the stream */

-FRESULT f_mkfs (BYTE, BYTE, WORD);					/* Create a file system on the drive */

-FRESULT f_chdir (const XCHAR*);						/* Change current directory */

-FRESULT f_chdrive (BYTE);							/* Change current drive */

-

-#if _USE_STRFUNC

-int f_putc (int, FIL*);								/* Put a character to the file */

-int f_puts (const char*, FIL*);						/* Put a string to the file */

-int f_printf (FIL*, const char*, ...);				/* Put a formatted string to the file */

-char* f_gets (char*, int, FIL*);					/* Get a string from the file */

-#define f_eof(fp) (((fp)->fptr == (fp)->fsize) ? 1 : 0)

-#define f_error(fp) (((fp)->flag & FA__ERROR) ? 1 : 0)

-#ifndef EOF

-#define EOF -1

-#endif

-#endif

-

-

-

-/*--------------------------------------------------------------*/

-/* User defined functions                                       */

-

-/* Real time clock */

-#if !_FS_READONLY

-DWORD get_fattime (void);	/* 31-25: Year(0-127 org.1980), 24-21: Month(1-12), 20-16: Day(1-31) */

-							/* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */

-#endif

-

-/* Unicode - OEM code conversion */

-#if _USE_LFN

-WCHAR ff_convert (WCHAR, UINT);

-WCHAR ff_wtoupper (WCHAR);

-#endif

-

-/* Sync functions */

-#if _FS_REENTRANT

-BOOL ff_cre_syncobj(BYTE, _SYNC_t*);

-BOOL ff_del_syncobj(_SYNC_t);

-BOOL ff_req_grant(_SYNC_t);

-void ff_rel_grant(_SYNC_t);

-#endif

-

-

-

-/*--------------------------------------------------------------*/

-/* Flags and offset address                                     */

-

-

-/* File access control and file status flags (FIL.flag) */

-

-#define	FA_READ				0x01

-#define	FA_OPEN_EXISTING	0x00

-#if _FS_READONLY == 0

-#define	FA_WRITE			0x02

-#define	FA_CREATE_NEW		0x04

-#define	FA_CREATE_ALWAYS	0x08

-#define	FA_OPEN_ALWAYS		0x10

-#define FA__WRITTEN			0x20

-#define FA__DIRTY			0x40

-#endif

-#define FA__ERROR			0x80

-

-

-/* FAT sub type (FATFS.fs_type) */

-

-#define FS_FAT12	1

-#define FS_FAT16	2

-#define FS_FAT32	3

-

-

-/* File attribute bits for directory entry */

-

-#define	AM_RDO	0x01	/* Read only */

-#define	AM_HID	0x02	/* Hidden */

-#define	AM_SYS	0x04	/* System */

-#define	AM_VOL	0x08	/* Volume label */

-#define AM_LFN	0x0F	/* LFN entry */

-#define AM_DIR	0x10	/* Directory */

-#define AM_ARC	0x20	/* Archive */

-#define AM_MASK	0x3F	/* Mask of defined bits */

-

-

-/* FatFs refers the members in the FAT structures with byte offset instead

-/ of structure member because there are incompatibility of the packing option

-/ between various compilers. */

-

-#define BS_jmpBoot			0

-#define BS_OEMName			3

-#define BPB_BytsPerSec		11

-#define BPB_SecPerClus		13

-#define BPB_RsvdSecCnt		14

-#define BPB_NumFATs			16

-#define BPB_RootEntCnt		17

-#define BPB_TotSec16		19

-#define BPB_Media			21

-#define BPB_FATSz16			22

-#define BPB_SecPerTrk		24

-#define BPB_NumHeads		26

-#define BPB_HiddSec			28

-#define BPB_TotSec32		32

-#define BS_55AA				510

-

-#define BS_DrvNum			36

-#define BS_BootSig			38

-#define BS_VolID			39

-#define BS_VolLab			43

-#define BS_FilSysType		54

-

-#define BPB_FATSz32			36

-#define BPB_ExtFlags		40

-#define BPB_FSVer			42

-#define BPB_RootClus		44

-#define BPB_FSInfo			48

-#define BPB_BkBootSec		50

-#define BS_DrvNum32			64

-#define BS_BootSig32		66

-#define BS_VolID32			67

-#define BS_VolLab32			71

-#define BS_FilSysType32		82

-

-#define	FSI_LeadSig			0

-#define	FSI_StrucSig		484

-#define	FSI_Free_Count		488

-#define	FSI_Nxt_Free		492

-

-#define MBR_Table			446

-

-#define	DIR_Name			0

-#define	DIR_Attr			11

-#define	DIR_NTres			12

-#define	DIR_CrtTime			14

-#define	DIR_CrtDate			16

-#define	DIR_FstClusHI		20

-#define	DIR_WrtTime			22

-#define	DIR_WrtDate			24

-#define	DIR_FstClusLO		26

-#define	DIR_FileSize		28

-#define	LDIR_Ord			0

-#define	LDIR_Attr			11

-#define	LDIR_Type			12

-#define	LDIR_Chksum			13

-#define	LDIR_FstClusLO		26

-

-

-

-/*--------------------------------*/

-/* Multi-byte word access macros  */

-

-#if _WORD_ACCESS == 1	/* Enable word access to the FAT structure */

-#define	LD_WORD(ptr)		(WORD)(*(WORD*)(BYTE*)(ptr))

-#define	LD_DWORD(ptr)		(DWORD)(*(DWORD*)(BYTE*)(ptr))

-#define	ST_WORD(ptr,val)	*(WORD*)(BYTE*)(ptr)=(WORD)(val)

-#define	ST_DWORD(ptr,val)	*(DWORD*)(BYTE*)(ptr)=(DWORD)(val)

-#else					/* Use byte-by-byte access to the FAT structure */

-#define	LD_WORD(ptr)		(WORD)(((WORD)*(BYTE*)((ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))

-#define	LD_DWORD(ptr)		(DWORD)(((DWORD)*(BYTE*)((ptr)+3)<<24)|((DWORD)*(BYTE*)((ptr)+2)<<16)|((WORD)*(BYTE*)((ptr)+1)<<8)|*(BYTE*)(ptr))

-#define	ST_WORD(ptr,val)	*(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8)

-#define	ST_DWORD(ptr,val)	*(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8); *(BYTE*)((ptr)+2)=(BYTE)((DWORD)(val)>>16); *(BYTE*)((ptr)+3)=(BYTE)((DWORD)(val)>>24)

-#endif

-

-

-#endif /* _FATFS */

+/*---------------------------------------------------------------------------/
+/  FatFs - FAT file system module include file  R0.07e       (C)ChaN, 2010
+/----------------------------------------------------------------------------/
+/ FatFs module is a generic FAT file system module for small embedded systems.
+/ This is a free software that opened for education, research and commercial
+/ developments under license policy of following trems.
+/
+/  Copyright (C) 2010, ChaN, all right reserved.
+/
+/ * The FatFs module is a free software and there is NO WARRANTY.
+/ * No restriction on use. You can use, modify and redistribute it for
+/   personal, non-profit or commercial product UNDER YOUR RESPONSIBILITY.
+/ * Redistributions of source code must retain the above copyright notice.
+/----------------------------------------------------------------------------*/
+
+#ifndef _FATFS
+#define _FATFS	0x007E
+
+#include "integer.h"	/* Basic integer types */
+#include "ffconf.h"		/* FatFs configuration options */
+
+#if _FATFS != _FFCONFIG
+#error Wrong configuration file (ffconf.h).
+#endif
+
+
+/* DBCS code ranges and SBCS extend char conversion table */
+
+#if _CODE_PAGE == 932	/* Japanese Shift-JIS */
+#define _DF1S	0x81	/* DBC 1st byte range 1 start */
+#define _DF1E	0x9F	/* DBC 1st byte range 1 end */
+#define _DF2S	0xE0	/* DBC 1st byte range 2 start */
+#define _DF2E	0xFC	/* DBC 1st byte range 2 end */
+#define _DS1S	0x40	/* DBC 2nd byte range 1 start */
+#define _DS1E	0x7E	/* DBC 2nd byte range 1 end */
+#define _DS2S	0x80	/* DBC 2nd byte range 2 start */
+#define _DS2E	0xFC	/* DBC 2nd byte range 2 end */
+
+#elif _CODE_PAGE == 936	/* Simplified Chinese GBK */
+#define _DF1S	0x81
+#define _DF1E	0xFE
+#define _DS1S	0x40
+#define _DS1E	0x7E
+#define _DS2S	0x80
+#define _DS2E	0xFE
+
+#elif _CODE_PAGE == 949	/* Korean */
+#define _DF1S	0x81
+#define _DF1E	0xFE
+#define _DS1S	0x41
+#define _DS1E	0x5A
+#define _DS2S	0x61
+#define _DS2E	0x7A
+#define _DS3S	0x81
+#define _DS3E	0xFE
+
+#elif _CODE_PAGE == 950	/* Traditional Chinese Big5 */
+#define _DF1S	0x81
+#define _DF1E	0xFE
+#define _DS1S	0x40
+#define _DS1E	0x7E
+#define _DS2S	0xA1
+#define _DS2E	0xFE
+
+#elif _CODE_PAGE == 437	/* U.S. (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x9A,0x90,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x49,0x49,0x49,0x8E,0x8F,0x90,0x92,0x92,0x4F,0x99,0x4F,0x55,0x55,0x59,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+				0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 720	/* Arabic (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x45,0x41,0x84,0x41,0x86,0x43,0x45,0x45,0x45,0x49,0x49,0x8D,0x8E,0x8F,0x90,0x92,0x92,0x93,0x94,0x95,0x49,0x49,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 737	/* Greek (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x92,0x92,0x93,0x94,0x95,0x96,0x97,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87, \
+				0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0xAA,0x92,0x93,0x94,0x95,0x96,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0x97,0xEA,0xEB,0xEC,0xE4,0xED,0xEE,0xE7,0xE8,0xF1,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 775	/* Baltic (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x9A,0x91,0xA0,0x8E,0x95,0x8F,0x80,0xAD,0xED,0x8A,0x8A,0xA1,0x8D,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0x95,0x96,0x97,0x97,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \
+				0xA0,0xA1,0xE0,0xA3,0xA3,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xB5,0xB6,0xB7,0xB8,0xBD,0xBE,0xC6,0xC7,0xA5,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE3,0xE8,0xE8,0xEA,0xEA,0xEE,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 850	/* Multilingual Latin 1 (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0xDE,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x59,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \
+				0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE7,0xE9,0xEA,0xEB,0xED,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 852	/* Latin 2 (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xDE,0x8F,0x80,0x9D,0xD3,0x8A,0x8A,0xD7,0x8D,0x8E,0x8F,0x90,0x91,0x91,0xE2,0x99,0x95,0x95,0x97,0x97,0x99,0x9A,0x9B,0x9B,0x9D,0x9E,0x9F, \
+				0xB5,0xD6,0xE0,0xE9,0xA4,0xA4,0xA6,0xA6,0xA8,0xA8,0xAA,0x8D,0xAC,0xB8,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBD,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC6,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD1,0xD1,0xD2,0xD3,0xD2,0xD5,0xD6,0xD7,0xB7,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xE0,0xE1,0xE2,0xE3,0xE3,0xD5,0xE6,0xE6,0xE8,0xE9,0xE8,0xEB,0xED,0xED,0xDD,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xEB,0xFC,0xFC,0xFE,0xFF}
+
+#elif _CODE_PAGE == 855	/* Cyrillic (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x81,0x81,0x83,0x83,0x85,0x85,0x87,0x87,0x89,0x89,0x8B,0x8B,0x8D,0x8D,0x8F,0x8F,0x91,0x91,0x93,0x93,0x95,0x95,0x97,0x97,0x99,0x99,0x9B,0x9B,0x9D,0x9D,0x9F,0x9F, \
+				0xA1,0xA1,0xA3,0xA3,0xA5,0xA5,0xA7,0xA7,0xA9,0xA9,0xAB,0xAB,0xAD,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB6,0xB6,0xB8,0xB8,0xB9,0xBA,0xBB,0xBC,0xBE,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD1,0xD1,0xD3,0xD3,0xD5,0xD5,0xD7,0xD7,0xDD,0xD9,0xDA,0xDB,0xDC,0xDD,0xE0,0xDF, \
+				0xE0,0xE2,0xE2,0xE4,0xE4,0xE6,0xE6,0xE8,0xE8,0xEA,0xEA,0xEC,0xEC,0xEE,0xEE,0xEF,0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF8,0xFA,0xFA,0xFC,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 857	/* Turkish (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0x98,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x98,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9E, \
+				0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA6,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xDE,0x59,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 858	/* Multilingual Latin 1 + Euro (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0xDE,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x59,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \
+				0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD1,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE7,0xE9,0xEA,0xEB,0xED,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 862	/* Hebrew (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+				0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 866	/* Russian (OEM) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+				0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0x90,0x91,0x92,0x93,0x9d,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xF0,0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 874	/* Thai (OEM, Windows) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 1250 /* Central Europe (Windows) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x8D,0x8E,0x8F, \
+				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xA3,0xB4,0xB5,0xB6,0xB7,0xB8,0xA5,0xAA,0xBB,0xBC,0xBD,0xBC,0xAF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xFF}
+
+#elif _CODE_PAGE == 1251 /* Cyrillic (Windows) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x82,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x80,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x8D,0x8E,0x8F, \
+				0xA0,0xA2,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB2,0xA5,0xB5,0xB6,0xB7,0xA8,0xB9,0xAA,0xBB,0xA3,0xBD,0xBD,0xAF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF}
+
+#elif _CODE_PAGE == 1252 /* Latin 1 (Windows) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xAd,0x9B,0x8C,0x9D,0xAE,0x9F, \
+				0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x9F}
+
+#elif _CODE_PAGE == 1253 /* Greek (Windows) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xA2,0xB8,0xB9,0xBA, \
+				0xE0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xF2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xFB,0xBC,0xFD,0xBF,0xFF}
+
+#elif _CODE_PAGE == 1254 /* Turkish (Windows) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x9D,0x9E,0x9F, \
+				0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x9F}
+
+#elif _CODE_PAGE == 1255 /* Hebrew (Windows) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+				0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 1256 /* Arabic (Windows) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x8C,0x9D,0x9E,0x9F, \
+				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0x41,0xE1,0x41,0xE3,0xE4,0xE5,0xE6,0x43,0x45,0x45,0x45,0x45,0xEC,0xED,0x49,0x49,0xF0,0xF1,0xF2,0xF3,0x4F,0xF5,0xF6,0xF7,0xF8,0x55,0xFA,0x55,0x55,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 1257 /* Baltic (Windows) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+				0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xA8,0xB9,0xAA,0xBB,0xBC,0xBD,0xBE,0xAF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xFF}
+
+#elif _CODE_PAGE == 1258 /* Vietnam (OEM, Windows) */
+#define _DF1S	0
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0xAC,0x9D,0x9E,0x9F, \
+				0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+				0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xEC,0xCD,0xCE,0xCF,0xD0,0xD1,0xF2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xFE,0x9F}
+
+#elif _CODE_PAGE == 1	/* ASCII (for only non-LFN cfg) */
+#define _DF1S	0
+
+#else
+#error Unknown code page
+
+#endif
+
+
+
+/* Character code support macros */
+
+#define IsUpper(c)	(((c)>='A')&&((c)<='Z'))
+#define IsLower(c)	(((c)>='a')&&((c)<='z'))
+
+#if _DF1S		/* DBCS configuration */
+
+#ifdef _DF2S	/* Two 1st byte areas */
+#define IsDBCS1(c)	(((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E) || ((BYTE)(c) >= _DF2S && (BYTE)(c) <= _DF2E))
+#else			/* One 1st byte area */
+#define IsDBCS1(c)	((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E)
+#endif
+
+#ifdef _DS3S	/* Three 2nd byte areas */
+#define IsDBCS2(c)	(((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E) || ((BYTE)(c) >= _DS3S && (BYTE)(c) <= _DS3E))
+#else			/* Two 2nd byte areas */
+#define IsDBCS2(c)	(((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E))
+#endif
+
+#else			/* SBCS configuration */
+
+#define IsDBCS1(c)	0
+#define IsDBCS2(c)	0
+
+#endif /* _DF1S */
+
+
+
+/* Definitions corresponds to multi partition */
+
+#if _MULTI_PARTITION		/* Multiple partition configuration */
+
+typedef struct _PARTITION {
+	BYTE pd;	/* Physical drive# */
+	BYTE pt;	/* Partition # (0-3) */
+} PARTITION;
+
+extern
+const PARTITION Drives[];			/* Logical drive# to physical location conversion table */
+#define LD2PD(drv) (Drives[drv].pd)	/* Get physical drive# */
+#define LD2PT(drv) (Drives[drv].pt)	/* Get partition# */
+
+#else						/* Single partition configuration */
+
+#define LD2PD(drv) (drv)	/* Physical drive# is equal to the logical drive# */
+#define LD2PT(drv) 0		/* Always mounts the 1st partition */
+
+#endif
+
+
+
+/* Definitions corresponds to multiple sector size */
+
+#if _MAX_SS == 512		/* Single sector size */
+#define	SS(fs)	512U
+
+#elif _MAX_SS == 1024 || _MAX_SS == 2048 || _MAX_SS == 4096	/* Multiple sector size */
+#define	SS(fs)	((fs)->s_size)
+
+#else
+#error Sector size must be 512, 1024, 2048 or 4096.
+
+#endif
+
+
+
+/* Type of file name on FatFs API */
+
+#if _LFN_UNICODE && _USE_LFN
+typedef WCHAR XCHAR;	/* Unicode */
+#else
+typedef char XCHAR;		/* SBCS, DBCS */
+#endif
+
+
+
+/* File system object structure */
+
+typedef struct _FATFS_ {
+	BYTE	fs_type;	/* FAT sub type */
+	BYTE	drive;		/* Physical drive number */
+	BYTE	csize;		/* Number of sectors per cluster */
+	BYTE	n_fats;		/* Number of FAT copies */
+	BYTE	wflag;		/* win[] dirty flag (1:must be written back) */
+	BYTE	fsi_flag;	/* fsinfo dirty flag (1:must be written back) */
+	WORD	id;			/* File system mount ID */
+	WORD	n_rootdir;	/* Number of root directory entries (0 on FAT32) */
+#if _FS_REENTRANT
+	_SYNC_t	sobj;		/* Identifier of sync object */
+#endif
+#if _MAX_SS != 512
+	WORD	s_size;		/* Sector size */
+#endif
+#if !_FS_READONLY
+	DWORD	last_clust;	/* Last allocated cluster */
+	DWORD	free_clust;	/* Number of free clusters */
+	DWORD	fsi_sector;	/* fsinfo sector */
+#endif
+#if _FS_RPATH
+	DWORD	cdir;		/* Current directory (0:root)*/
+#endif
+	DWORD	sects_fat;	/* Sectors per fat */
+	DWORD	max_clust;	/* Maximum cluster# + 1. Number of clusters is max_clust - 2 */
+	DWORD	fatbase;	/* FAT start sector */
+	DWORD	dirbase;	/* Root directory start sector (Cluster# on FAT32) */
+	DWORD	database;	/* Data start sector */
+	DWORD	winsect;	/* Current sector appearing in the win[] */
+	BYTE	win[_MAX_SS];/* Disk access window for Directory/FAT */
+} FATFS;
+
+
+
+/* Directory object structure */
+
+typedef struct _DIR_ {
+	FATFS*	fs;			/* Pointer to the owner file system object */
+	WORD	id;			/* Owner file system mount ID */
+	WORD	index;		/* Current read/write index number */
+	DWORD	sclust;		/* Table start cluster (0:Static table) */
+	DWORD	clust;		/* Current cluster */
+	DWORD	sect;		/* Current sector */
+	BYTE*	dir;		/* Pointer to the current SFN entry in the win[] */
+	BYTE*	fn;			/* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
+#if _USE_LFN
+	WCHAR*	lfn;		/* Pointer to the LFN working buffer */
+	WORD	lfn_idx;	/* Last matched LFN index number (0xFFFF:No LFN) */
+#endif
+} DIR;
+
+
+
+/* File object structure */
+
+typedef struct _FIL_ {
+	FATFS*	fs;			/* Pointer to the owner file system object */
+	WORD	id;			/* Owner file system mount ID */
+	BYTE	flag;		/* File status flags */
+	BYTE	csect;		/* Sector address in the cluster */
+	DWORD	fptr;		/* File R/W pointer */
+	DWORD	fsize;		/* File size */
+	DWORD	org_clust;	/* File start cluster */
+	DWORD	curr_clust;	/* Current cluster */
+	DWORD	dsect;		/* Current data sector */
+#if !_FS_READONLY
+	DWORD	dir_sect;	/* Sector containing the directory entry */
+	BYTE*	dir_ptr;	/* Ponter to the directory entry in the window */
+#endif
+#if !_FS_TINY
+	BYTE	buf[_MAX_SS];/* File R/W buffer */
+#endif
+} FIL;
+
+
+
+/* File status structure */
+
+typedef struct _FILINFO_ {
+	DWORD	fsize;		/* File size */
+	WORD	fdate;		/* Last modified date */
+	WORD	ftime;		/* Last modified time */
+	BYTE	fattrib;	/* Attribute */
+	char	fname[13];	/* Short file name (8.3 format) */
+#if _USE_LFN
+	XCHAR*	lfname;		/* Pointer to the LFN buffer */
+	int 	lfsize;		/* Size of LFN buffer [chrs] */
+#endif
+} FILINFO;
+
+
+
+/* File function return code (FRESULT) */
+
+typedef enum {
+	FR_OK = 0,			/* 0 */
+	FR_DISK_ERR,		/* 1 */
+	FR_INT_ERR,			/* 2 */
+	FR_NOT_READY,		/* 3 */
+	FR_NO_FILE,			/* 4 */
+	FR_NO_PATH,			/* 5 */
+	FR_INVALID_NAME,	/* 6 */
+	FR_DENIED,			/* 7 */
+	FR_EXIST,			/* 8 */
+	FR_INVALID_OBJECT,	/* 9 */
+	FR_WRITE_PROTECTED,	/* 10 */
+	FR_INVALID_DRIVE,	/* 11 */
+	FR_NOT_ENABLED,		/* 12 */
+	FR_NO_FILESYSTEM,	/* 13 */
+	FR_MKFS_ABORTED,	/* 14 */
+	FR_TIMEOUT			/* 15 */
+} FRESULT;
+
+
+
+/*--------------------------------------------------------------*/
+/* FatFs module application interface                           */
+
+FRESULT f_mount (BYTE, FATFS*);						/* Mount/Unmount a logical drive */
+FRESULT f_open (FIL*, const XCHAR*, BYTE);			/* Open or create a file */
+FRESULT f_read (FIL*, void*, UINT, UINT*);			/* Read data from a file */
+FRESULT f_write (FIL*, const void*, UINT, UINT*);	/* Write data to a file */
+FRESULT f_lseek (FIL*, DWORD);						/* Move file pointer of a file object */
+FRESULT f_close (FIL*);								/* Close an open file object */
+FRESULT f_opendir (DIR*, const XCHAR*);				/* Open an existing directory */
+FRESULT f_readdir (DIR*, FILINFO*);					/* Read a directory item */
+FRESULT f_stat (const XCHAR*, FILINFO*);			/* Get file status */
+FRESULT f_getfree (const XCHAR*, DWORD*, FATFS**);	/* Get number of free clusters on the drive */
+FRESULT f_truncate (FIL*);							/* Truncate file */
+FRESULT f_sync (FIL*);								/* Flush cached data of a writing file */
+FRESULT f_unlink (const XCHAR*);					/* Delete an existing file or directory */
+FRESULT	f_mkdir (const XCHAR*);						/* Create a new directory */
+FRESULT f_chmod (const XCHAR*, BYTE, BYTE);			/* Change attriburte of the file/dir */
+FRESULT f_utime (const XCHAR*, const FILINFO*);		/* Change timestamp of the file/dir */
+FRESULT f_rename (const XCHAR*, const XCHAR*);		/* Rename/Move a file or directory */
+FRESULT f_forward (FIL*, UINT(*)(const BYTE*,UINT), UINT, UINT*);	/* Forward data to the stream */
+FRESULT f_mkfs (BYTE, BYTE, WORD);					/* Create a file system on the drive */
+FRESULT f_chdir (const XCHAR*);						/* Change current directory */
+FRESULT f_chdrive (BYTE);							/* Change current drive */
+
+#if _USE_STRFUNC
+int f_putc (int, FIL*);								/* Put a character to the file */
+int f_puts (const char*, FIL*);						/* Put a string to the file */
+int f_printf (FIL*, const char*, ...);				/* Put a formatted string to the file */
+char* f_gets (char*, int, FIL*);					/* Get a string from the file */
+#define f_eof(fp) (((fp)->fptr == (fp)->fsize) ? 1 : 0)
+#define f_error(fp) (((fp)->flag & FA__ERROR) ? 1 : 0)
+#ifndef EOF
+#define EOF -1
+#endif
+#endif
+
+
+
+/*--------------------------------------------------------------*/
+/* User defined functions                                       */
+
+/* Real time clock */
+#if !_FS_READONLY
+DWORD get_fattime (void);	/* 31-25: Year(0-127 org.1980), 24-21: Month(1-12), 20-16: Day(1-31) */
+							/* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */
+#endif
+
+/* Unicode - OEM code conversion */
+#if _USE_LFN
+WCHAR ff_convert (WCHAR, UINT);
+WCHAR ff_wtoupper (WCHAR);
+#endif
+
+/* Sync functions */
+#if _FS_REENTRANT
+BOOL ff_cre_syncobj(BYTE, _SYNC_t*);
+BOOL ff_del_syncobj(_SYNC_t);
+BOOL ff_req_grant(_SYNC_t);
+void ff_rel_grant(_SYNC_t);
+#endif
+
+
+
+/*--------------------------------------------------------------*/
+/* Flags and offset address                                     */
+
+
+/* File access control and file status flags (FIL.flag) */
+
+#define	FA_READ				0x01
+#define	FA_OPEN_EXISTING	0x00
+#if _FS_READONLY == 0
+#define	FA_WRITE			0x02
+#define	FA_CREATE_NEW		0x04
+#define	FA_CREATE_ALWAYS	0x08
+#define	FA_OPEN_ALWAYS		0x10
+#define FA__WRITTEN			0x20
+#define FA__DIRTY			0x40
+#endif
+#define FA__ERROR			0x80
+
+
+/* FAT sub type (FATFS.fs_type) */
+
+#define FS_FAT12	1
+#define FS_FAT16	2
+#define FS_FAT32	3
+
+
+/* File attribute bits for directory entry */
+
+#define	AM_RDO	0x01	/* Read only */
+#define	AM_HID	0x02	/* Hidden */
+#define	AM_SYS	0x04	/* System */
+#define	AM_VOL	0x08	/* Volume label */
+#define AM_LFN	0x0F	/* LFN entry */
+#define AM_DIR	0x10	/* Directory */
+#define AM_ARC	0x20	/* Archive */
+#define AM_MASK	0x3F	/* Mask of defined bits */
+
+
+/* FatFs refers the members in the FAT structures with byte offset instead
+/ of structure member because there are incompatibility of the packing option
+/ between various compilers. */
+
+#define BS_jmpBoot			0
+#define BS_OEMName			3
+#define BPB_BytsPerSec		11
+#define BPB_SecPerClus		13
+#define BPB_RsvdSecCnt		14
+#define BPB_NumFATs			16
+#define BPB_RootEntCnt		17
+#define BPB_TotSec16		19
+#define BPB_Media			21
+#define BPB_FATSz16			22
+#define BPB_SecPerTrk		24
+#define BPB_NumHeads		26
+#define BPB_HiddSec			28
+#define BPB_TotSec32		32
+#define BS_55AA				510
+
+#define BS_DrvNum			36
+#define BS_BootSig			38
+#define BS_VolID			39
+#define BS_VolLab			43
+#define BS_FilSysType		54
+
+#define BPB_FATSz32			36
+#define BPB_ExtFlags		40
+#define BPB_FSVer			42
+#define BPB_RootClus		44
+#define BPB_FSInfo			48
+#define BPB_BkBootSec		50
+#define BS_DrvNum32			64
+#define BS_BootSig32		66
+#define BS_VolID32			67
+#define BS_VolLab32			71
+#define BS_FilSysType32		82
+
+#define	FSI_LeadSig			0
+#define	FSI_StrucSig		484
+#define	FSI_Free_Count		488
+#define	FSI_Nxt_Free		492
+
+#define MBR_Table			446
+
+#define	DIR_Name			0
+#define	DIR_Attr			11
+#define	DIR_NTres			12
+#define	DIR_CrtTime			14
+#define	DIR_CrtDate			16
+#define	DIR_FstClusHI		20
+#define	DIR_WrtTime			22
+#define	DIR_WrtDate			24
+#define	DIR_FstClusLO		26
+#define	DIR_FileSize		28
+#define	LDIR_Ord			0
+#define	LDIR_Attr			11
+#define	LDIR_Type			12
+#define	LDIR_Chksum			13
+#define	LDIR_FstClusLO		26
+
+
+
+/*--------------------------------*/
+/* Multi-byte word access macros  */
+
+#if _WORD_ACCESS == 1	/* Enable word access to the FAT structure */
+#define	LD_WORD(ptr)		(WORD)(*(WORD*)(BYTE*)(ptr))
+#define	LD_DWORD(ptr)		(DWORD)(*(DWORD*)(BYTE*)(ptr))
+#define	ST_WORD(ptr,val)	*(WORD*)(BYTE*)(ptr)=(WORD)(val)
+#define	ST_DWORD(ptr,val)	*(DWORD*)(BYTE*)(ptr)=(DWORD)(val)
+#else					/* Use byte-by-byte access to the FAT structure */
+#define	LD_WORD(ptr)		(WORD)(((WORD)*(BYTE*)((ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))
+#define	LD_DWORD(ptr)		(DWORD)(((DWORD)*(BYTE*)((ptr)+3)<<24)|((DWORD)*(BYTE*)((ptr)+2)<<16)|((WORD)*(BYTE*)((ptr)+1)<<8)|*(BYTE*)(ptr))
+#define	ST_WORD(ptr,val)	*(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8)
+#define	ST_DWORD(ptr,val)	*(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8); *(BYTE*)((ptr)+2)=(BYTE)((DWORD)(val)>>16); *(BYTE*)((ptr)+3)=(BYTE)((DWORD)(val)>>24)
+#endif
+
+
+#endif /* _FATFS */
diff --git a/Projects/Webserver/Lib/FATFs/ffconf.h b/Projects/Webserver/Lib/FATFs/ffconf.h
index 4b19f1326..a82109469 100644
--- a/Projects/Webserver/Lib/FATFs/ffconf.h
+++ b/Projects/Webserver/Lib/FATFs/ffconf.h
@@ -1,166 +1,166 @@
-/*---------------------------------------------------------------------------/

-/  FatFs - FAT file system module configuration file  R0.07e  (C)ChaN, 2010

-/----------------------------------------------------------------------------/

-/

-/ CAUTION! Do not forget to make clean the project after any changes to

-/ the configuration options.

-/

-/----------------------------------------------------------------------------*/

-#ifndef _FFCONFIG

-#define _FFCONFIG 0x007E

-

-

-/*---------------------------------------------------------------------------/

-/ Function and Buffer Configurations

-/----------------------------------------------------------------------------*/

-

-#define	_FS_TINY	1		/* 0 or 1 */

-/* When _FS_TINY is set to 1, FatFs uses the sector buffer in the file system

-/  object instead of the sector buffer in the individual file object for file

-/  data transfer. This reduces memory consumption 512 bytes each file object. */

-

-

-#define _FS_READONLY	1	/* 0 or 1 */

-/* Setting _FS_READONLY to 1 defines read only configuration. This removes

-/  writing functions, f_write, f_sync, f_unlink, f_mkdir, f_chmod, f_rename,

-/  f_truncate and useless f_getfree. */

-

-

-#define _FS_MINIMIZE	2	/* 0, 1, 2 or 3 */

-/* The _FS_MINIMIZE option defines minimization level to remove some functions.

-/

-/   0: Full function.

-/   1: f_stat, f_getfree, f_unlink, f_mkdir, f_chmod, f_truncate and f_rename

-/      are removed.

-/   2: f_opendir and f_readdir are removed in addition to level 1.

-/   3: f_lseek is removed in addition to level 2. */

-

-

-#define	_USE_STRFUNC	0	/* 0, 1 or 2 */

-/* To enable string functions, set _USE_STRFUNC to 1 or 2. */

-

-

-#define	_USE_MKFS	0		/* 0 or 1 */

-/* To enable f_mkfs function, set _USE_MKFS to 1 and set _FS_READONLY to 0 */

-

-

-#define	_USE_FORWARD	0	/* 0 or 1 */

-/* To enable f_forward function, set _USE_FORWARD to 1 and set _FS_TINY to 1. */

-

-

-

-/*---------------------------------------------------------------------------/

-/ Locale and Namespace Configurations

-/----------------------------------------------------------------------------*/

-

-#define _CODE_PAGE	932

-/* The _CODE_PAGE specifies the OEM code page to be used on the target system.

-/  Incorrect setting of the code page can cause a file open failure.

-/

-/   932  - Japanese Shift-JIS (DBCS, OEM, Windows)

-/   936  - Simplified Chinese GBK (DBCS, OEM, Windows)

-/   949  - Korean (DBCS, OEM, Windows)

-/   950  - Traditional Chinese Big5 (DBCS, OEM, Windows)

-/   1250 - Central Europe (Windows)

-/   1251 - Cyrillic (Windows)

-/   1252 - Latin 1 (Windows)

-/   1253 - Greek (Windows)

-/   1254 - Turkish (Windows)

-/   1255 - Hebrew (Windows)

-/   1256 - Arabic (Windows)

-/   1257 - Baltic (Windows)

-/   1258 - Vietnam (OEM, Windows)

-/   437  - U.S. (OEM)

-/   720  - Arabic (OEM)

-/   737  - Greek (OEM)

-/   775  - Baltic (OEM)

-/   850  - Multilingual Latin 1 (OEM)

-/   858  - Multilingual Latin 1 + Euro (OEM)

-/   852  - Latin 2 (OEM)

-/   855  - Cyrillic (OEM)

-/   866  - Russian (OEM)

-/   857  - Turkish (OEM)

-/   862  - Hebrew (OEM)

-/   874  - Thai (OEM, Windows)

-/	1    - ASCII only (Valid for non LFN cfg.)

-*/

-

-

-#define	_USE_LFN	0		/* 0, 1 or 2 */

-#define	_MAX_LFN	255		/* Maximum LFN length to handle (12 to 255) */

-/* The _USE_LFN option switches the LFN support.

-/

-/   0: Disable LFN. _MAX_LFN and _LFN_UNICODE have no effect.

-/   1: Enable LFN with static working buffer on the bss. NOT REENTRANT.

-/   2: Enable LFN with dynamic working buffer on the STACK.

-/

-/  The LFN working buffer occupies (_MAX_LFN + 1) * 2 bytes. When enable LFN,

-/  two Unicode handling functions ff_convert() and ff_wtoupper() must be added

-/  to the project. */

-

-

-#define	_LFN_UNICODE	0	/* 0 or 1 */

-/* To switch the character code set on FatFs API to Unicode,

-/  enable LFN feature and set _LFN_UNICODE to 1.

-*/

-

-

-#define _FS_RPATH	0		/* 0 or 1 */

-/* When _FS_RPATH is set to 1, relative path feature is enabled and f_chdir,

-/  f_chdrive function are available.

-/  Note that output of the f_readdir fnction is affected by this option. */

-

-

-

-/*---------------------------------------------------------------------------/

-/ Physical Drive Configurations

-/----------------------------------------------------------------------------*/

-

-#define _DRIVES		1

-/* Number of volumes (logical drives) to be used. */

-

-

-#define	_MAX_SS		512		/* 512, 1024, 2048 or 4096 */

-/* Maximum sector size to be handled.

-/  Always set 512 for memory card and hard disk but a larger value may be

-/  required for floppy disk (512/1024) and optical disk (512/2048).

-/  When _MAX_SS is larger than 512, GET_SECTOR_SIZE command must be implememted

-/  to the disk_ioctl function. */

-

-

-#define	_MULTI_PARTITION	0	/* 0 or 1 */

-/* When _MULTI_PARTITION is set to 0, each volume is bound to the same physical

-/ drive number and can mount only first primaly partition. When it is set to 1,

-/ each volume is tied to the partitions listed in Drives[]. */

-

-

-

-/*---------------------------------------------------------------------------/

-/ System Configurations

-/----------------------------------------------------------------------------*/

-

-#define _WORD_ACCESS	1	/* 0 or 1 */

-/* The _WORD_ACCESS option defines which access method is used to the word

-/  data on the FAT volume.

-/

-/   0: Byte-by-byte access. Always compatible with all platforms.

-/   1: Word access. Do not choose this unless following condition is met.

-/

-/  When the byte order on the memory is big-endian or address miss-aligned

-/  word access results incorrect behavior, the _WORD_ACCESS must be set to 0.

-/  If it is not the case, the value can also be set to 1 to improve the

-/  performance and code size. */

-

-

-#define _FS_REENTRANT	0		/* 0 or 1 */

-#define _FS_TIMEOUT		1000	/* Timeout period in unit of time ticks */

-#define	_SYNC_t			HANDLE	/* O/S dependent type of sync object. e.g. HANDLE, OS_EVENT*, ID and etc.. */

-/* The _FS_REENTRANT option switches the reentrancy of the FatFs module.

-/

-/   0: Disable reentrancy. _SYNC_t and _FS_TIMEOUT have no effect.

-/   1: Enable reentrancy. Also user provided synchronization handlers,

-/      ff_req_grant, ff_rel_grant, ff_del_syncobj and ff_cre_syncobj

-/      function must be added to the project. */

-

-

-#endif /* _FFCONFIG */

+/*---------------------------------------------------------------------------/
+/  FatFs - FAT file system module configuration file  R0.07e  (C)ChaN, 2010
+/----------------------------------------------------------------------------/
+/
+/ CAUTION! Do not forget to make clean the project after any changes to
+/ the configuration options.
+/
+/----------------------------------------------------------------------------*/
+#ifndef _FFCONFIG
+#define _FFCONFIG 0x007E
+
+
+/*---------------------------------------------------------------------------/
+/ Function and Buffer Configurations
+/----------------------------------------------------------------------------*/
+
+#define	_FS_TINY	1		/* 0 or 1 */
+/* When _FS_TINY is set to 1, FatFs uses the sector buffer in the file system
+/  object instead of the sector buffer in the individual file object for file
+/  data transfer. This reduces memory consumption 512 bytes each file object. */
+
+
+#define _FS_READONLY	1	/* 0 or 1 */
+/* Setting _FS_READONLY to 1 defines read only configuration. This removes
+/  writing functions, f_write, f_sync, f_unlink, f_mkdir, f_chmod, f_rename,
+/  f_truncate and useless f_getfree. */
+
+
+#define _FS_MINIMIZE	2	/* 0, 1, 2 or 3 */
+/* The _FS_MINIMIZE option defines minimization level to remove some functions.
+/
+/   0: Full function.
+/   1: f_stat, f_getfree, f_unlink, f_mkdir, f_chmod, f_truncate and f_rename
+/      are removed.
+/   2: f_opendir and f_readdir are removed in addition to level 1.
+/   3: f_lseek is removed in addition to level 2. */
+
+
+#define	_USE_STRFUNC	0	/* 0, 1 or 2 */
+/* To enable string functions, set _USE_STRFUNC to 1 or 2. */
+
+
+#define	_USE_MKFS	0		/* 0 or 1 */
+/* To enable f_mkfs function, set _USE_MKFS to 1 and set _FS_READONLY to 0 */
+
+
+#define	_USE_FORWARD	0	/* 0 or 1 */
+/* To enable f_forward function, set _USE_FORWARD to 1 and set _FS_TINY to 1. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ Locale and Namespace Configurations
+/----------------------------------------------------------------------------*/
+
+#define _CODE_PAGE	932
+/* The _CODE_PAGE specifies the OEM code page to be used on the target system.
+/  Incorrect setting of the code page can cause a file open failure.
+/
+/   932  - Japanese Shift-JIS (DBCS, OEM, Windows)
+/   936  - Simplified Chinese GBK (DBCS, OEM, Windows)
+/   949  - Korean (DBCS, OEM, Windows)
+/   950  - Traditional Chinese Big5 (DBCS, OEM, Windows)
+/   1250 - Central Europe (Windows)
+/   1251 - Cyrillic (Windows)
+/   1252 - Latin 1 (Windows)
+/   1253 - Greek (Windows)
+/   1254 - Turkish (Windows)
+/   1255 - Hebrew (Windows)
+/   1256 - Arabic (Windows)
+/   1257 - Baltic (Windows)
+/   1258 - Vietnam (OEM, Windows)
+/   437  - U.S. (OEM)
+/   720  - Arabic (OEM)
+/   737  - Greek (OEM)
+/   775  - Baltic (OEM)
+/   850  - Multilingual Latin 1 (OEM)
+/   858  - Multilingual Latin 1 + Euro (OEM)
+/   852  - Latin 2 (OEM)
+/   855  - Cyrillic (OEM)
+/   866  - Russian (OEM)
+/   857  - Turkish (OEM)
+/   862  - Hebrew (OEM)
+/   874  - Thai (OEM, Windows)
+/	1    - ASCII only (Valid for non LFN cfg.)
+*/
+
+
+#define	_USE_LFN	0		/* 0, 1 or 2 */
+#define	_MAX_LFN	255		/* Maximum LFN length to handle (12 to 255) */
+/* The _USE_LFN option switches the LFN support.
+/
+/   0: Disable LFN. _MAX_LFN and _LFN_UNICODE have no effect.
+/   1: Enable LFN with static working buffer on the bss. NOT REENTRANT.
+/   2: Enable LFN with dynamic working buffer on the STACK.
+/
+/  The LFN working buffer occupies (_MAX_LFN + 1) * 2 bytes. When enable LFN,
+/  two Unicode handling functions ff_convert() and ff_wtoupper() must be added
+/  to the project. */
+
+
+#define	_LFN_UNICODE	0	/* 0 or 1 */
+/* To switch the character code set on FatFs API to Unicode,
+/  enable LFN feature and set _LFN_UNICODE to 1.
+*/
+
+
+#define _FS_RPATH	0		/* 0 or 1 */
+/* When _FS_RPATH is set to 1, relative path feature is enabled and f_chdir,
+/  f_chdrive function are available.
+/  Note that output of the f_readdir fnction is affected by this option. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ Physical Drive Configurations
+/----------------------------------------------------------------------------*/
+
+#define _DRIVES		1
+/* Number of volumes (logical drives) to be used. */
+
+
+#define	_MAX_SS		512		/* 512, 1024, 2048 or 4096 */
+/* Maximum sector size to be handled.
+/  Always set 512 for memory card and hard disk but a larger value may be
+/  required for floppy disk (512/1024) and optical disk (512/2048).
+/  When _MAX_SS is larger than 512, GET_SECTOR_SIZE command must be implememted
+/  to the disk_ioctl function. */
+
+
+#define	_MULTI_PARTITION	0	/* 0 or 1 */
+/* When _MULTI_PARTITION is set to 0, each volume is bound to the same physical
+/ drive number and can mount only first primaly partition. When it is set to 1,
+/ each volume is tied to the partitions listed in Drives[]. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ System Configurations
+/----------------------------------------------------------------------------*/
+
+#define _WORD_ACCESS	1	/* 0 or 1 */
+/* The _WORD_ACCESS option defines which access method is used to the word
+/  data on the FAT volume.
+/
+/   0: Byte-by-byte access. Always compatible with all platforms.
+/   1: Word access. Do not choose this unless following condition is met.
+/
+/  When the byte order on the memory is big-endian or address miss-aligned
+/  word access results incorrect behavior, the _WORD_ACCESS must be set to 0.
+/  If it is not the case, the value can also be set to 1 to improve the
+/  performance and code size. */
+
+
+#define _FS_REENTRANT	0		/* 0 or 1 */
+#define _FS_TIMEOUT		1000	/* Timeout period in unit of time ticks */
+#define	_SYNC_t			HANDLE	/* O/S dependent type of sync object. e.g. HANDLE, OS_EVENT*, ID and etc.. */
+/* The _FS_REENTRANT option switches the reentrancy of the FatFs module.
+/
+/   0: Disable reentrancy. _SYNC_t and _FS_TIMEOUT have no effect.
+/   1: Enable reentrancy. Also user provided synchronization handlers,
+/      ff_req_grant, ff_rel_grant, ff_del_syncobj and ff_cre_syncobj
+/      function must be added to the project. */
+
+
+#endif /* _FFCONFIG */
diff --git a/Projects/Webserver/Lib/FATFs/integer.h b/Projects/Webserver/Lib/FATFs/integer.h
index 1d6bac368..851a78da2 100644
--- a/Projects/Webserver/Lib/FATFs/integer.h
+++ b/Projects/Webserver/Lib/FATFs/integer.h
@@ -1,37 +1,37 @@
-/*-------------------------------------------*/

-/* Integer type definitions for FatFs module */

-/*-------------------------------------------*/

-

-#ifndef _INTEGER

-

-#if 0

-#include <windows.h>

-#else

-

-/* These types must be 16-bit, 32-bit or larger integer */

-typedef int				INT;

-typedef unsigned int	UINT;

-

-/* These types must be 8-bit integer */

-typedef signed char		CHAR;

-typedef unsigned char	UCHAR;

-typedef unsigned char	BYTE;

-

-/* These types must be 16-bit integer */

-typedef short			SHORT;

-typedef unsigned short	USHORT;

-typedef unsigned short	WORD;

-typedef unsigned short	WCHAR;

-

-/* These types must be 32-bit integer */

-typedef long			LONG;

-typedef unsigned long	ULONG;

-typedef unsigned long	DWORD;

-

-/* Boolean type */

-typedef enum { FALSE = 0, TRUE } BOOL;

-

-#endif

-

-#define _INTEGER

-#endif

+/*-------------------------------------------*/
+/* Integer type definitions for FatFs module */
+/*-------------------------------------------*/
+
+#ifndef _INTEGER
+
+#if 0
+#include <windows.h>
+#else
+
+/* These types must be 16-bit, 32-bit or larger integer */
+typedef int				INT;
+typedef unsigned int	UINT;
+
+/* These types must be 8-bit integer */
+typedef signed char		CHAR;
+typedef unsigned char	UCHAR;
+typedef unsigned char	BYTE;
+
+/* These types must be 16-bit integer */
+typedef short			SHORT;
+typedef unsigned short	USHORT;
+typedef unsigned short	WORD;
+typedef unsigned short	WCHAR;
+
+/* These types must be 32-bit integer */
+typedef long			LONG;
+typedef unsigned long	ULONG;
+typedef unsigned long	DWORD;
+
+/* Boolean type */
+typedef enum { FALSE = 0, TRUE } BOOL;
+
+#endif
+
+#define _INTEGER
+#endif
diff --git a/Projects/Webserver/Lib/HTTPServerApp.c b/Projects/Webserver/Lib/HTTPServerApp.c
index 08d849433..646410f3d 100644
--- a/Projects/Webserver/Lib/HTTPServerApp.c
+++ b/Projects/Webserver/Lib/HTTPServerApp.c
@@ -1,289 +1,289 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-/** \file

- *

- *  Simple HTTP Webserver Application. When connected to the uIP stack,

- *  this will serve out files to HTTP clients on port 80.

- */

- 

-#define  INCLUDE_FROM_HTTPSERVERAPP_C

-#include "HTTPServerApp.h"

-

-/** HTTP server response header, for transmission before the page contents. This indicates to the host that a page exists at the

- *  given location, and gives extra connection information.

- */

-const char PROGMEM HTTP200Header[] = "HTTP/1.1 200 OK\r\n"

-                                     "Server: LUFA " LUFA_VERSION_STRING "\r\n"

-                                     "Connection: close\r\n"

-                                     "MIME-version: 1.0\r\n"

-                                     "Content-Type: ";

-

-/** HTTP server response header, for transmission before a resource not found error. This indicates to the host that the given

- *  given URL is invalid, and gives extra error information.

- */

-const char PROGMEM HTTP404Header[] = "HTTP/1.1 404 Not Found\r\n"

-                                     "Server: LUFA " LUFA_VERSION_STRING "\r\n"

-                                     "Connection: close\r\n"

-                                     "MIME-version: 1.0\r\n"

-                                     "Content-Type: text/plain\r\n\r\n"

-                                     "Error 404: File Not Found: /";

-

-/** Default filename to fetch when a directory is requested */

-const char PROGMEM DefaultDirFileName[] = "index.htm";

-

-/** Default MIME type sent if no other MIME type can be determined. */

-const char PROGMEM DefaultMIMEType[] = "text/plain";

-

-/** List of MIME types for each supported file extension. */

-const MIME_Type_t MIMETypes[] =

-	{

-		{.Extension = "htm", .MIMEType = "text/html"},

-		{.Extension = "jpg", .MIMEType = "image/jpeg"},

-		{.Extension = "gif", .MIMEType = "image/gif"},

-		{.Extension = "bmp", .MIMEType = "image/bmp"},

-		{.Extension = "png", .MIMEType = "image/png"},

-		{.Extension = "ico", .MIMEType = "image/x-icon"},

-		{.Extension = "exe", .MIMEType = "application/octet-stream"},

-		{.Extension = "gz",  .MIMEType = "application/x-gzip"},

-		{.Extension = "zip", .MIMEType = "application/zip"},

-		{.Extension = "pdf", .MIMEType = "application/pdf"},

-	};

-

-/** FATFs structure to hold the internal state of the FAT driver for the dataflash contents. */

-FATFS DiskFATState;

-

-

-/** Initialization function for the simple HTTP webserver. */

-void HTTPServerApp_Init(void)

-{

-	/* Listen on port 80 for HTTP connections from hosts */

-	uip_listen(HTONS(HTTP_SERVER_PORT));

-	

-	/* Mount the dataflash disk via FatFS */

-	f_mount(0, &DiskFATState);

-}

-

-/** uIP stack application callback for the simple HTTP webserver. This function must be called each time the

- *  TCP/IP stack needs a TCP packet to be processed.

- */

-void HTTPServerApp_Callback(void)

-{

-	uip_tcp_appstate_t* const AppState = &uip_conn->appstate;

-

-	if (uip_aborted() || uip_timedout() || uip_closed())

-	{

-		/* Lock to the closed state so that no further processing will occur on the connection */

-		AppState->HTTPServer.CurrentState  = WEBSERVER_STATE_Closing;

-		AppState->HTTPServer.NextState     = WEBSERVER_STATE_Closing;

-	}

-

-	if (uip_connected())

-	{

-		/* New connection - initialize connection state values */

-		AppState->HTTPServer.CurrentState  = WEBSERVER_STATE_OpenRequestedFile;

-		AppState->HTTPServer.NextState     = WEBSERVER_STATE_OpenRequestedFile;

-		AppState->HTTPServer.FileOpen      = false;

-		AppState->HTTPServer.ACKedFilePos  = 0;

-		AppState->HTTPServer.SentChunkSize = 0;

-	}

-

-	if (uip_acked())

-	{

-		/* Add the amount of ACKed file data to the total sent file bytes counter */

-		AppState->HTTPServer.ACKedFilePos += AppState->HTTPServer.SentChunkSize;

-

-		/* Progress to the next state once the current state's data has been ACKed */

-		AppState->HTTPServer.CurrentState = AppState->HTTPServer.NextState;

-	}

-

-	if (uip_rexmit())

-	{

-		/* Return file pointer to the last ACKed position */

-		f_lseek(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.ACKedFilePos);	

-	}

-

-	if (uip_rexmit() || uip_acked() || uip_newdata() || uip_connected() || uip_poll())

-	{

-		switch (AppState->HTTPServer.CurrentState)

-		{

-			case WEBSERVER_STATE_OpenRequestedFile:

-				HTTPServerApp_OpenRequestedFile();

-				break;

-			case WEBSERVER_STATE_SendResponseHeader:

-				HTTPServerApp_SendResponseHeader();

-				break;

-			case WEBSERVER_STATE_SendData:

-				HTTPServerApp_SendData();

-				break;

-			case WEBSERVER_STATE_Closing:

-				/* Connection is being terminated for some reason - close file handle */

-				f_close(&AppState->HTTPServer.FileHandle);

-				AppState->HTTPServer.FileOpen = false;

-		

-				/* If connection is not already closed, close it */

-				uip_close();

-				

-				AppState->HTTPServer.CurrentState = WEBSERVER_STATE_Closed;

-				AppState->HTTPServer.NextState    = WEBSERVER_STATE_Closed;

-				break;

-		}		  

-	}		

-}

-

-/** HTTP Server State handler for the Request Process state. This state manages the processing of incoming HTTP

- *  GET requests to the server from the receiving HTTP client.

- */

-static void HTTPServerApp_OpenRequestedFile(void)

-{

-	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;

-	char*               const AppData     = (char*)uip_appdata;

-	

-	/* No HTTP header received from the client, abort processing */

-	if (!(uip_newdata()))

-	  return;

-	  

-	char* RequestToken      = strtok(AppData, " ");

-	char* RequestedFileName = strtok(NULL, " ");

-			

-	/* Must be a GET request, abort otherwise */

-	if (strcmp_P(RequestToken, PSTR("GET")) != 0)

-	{

-		uip_abort();

-		return;

-	}

-	

-	/* Copy over the requested filename */

-	strncpy(AppState->HTTPServer.FileName, &RequestedFileName[1], (sizeof(AppState->HTTPServer.FileName) - 1));

-	

-	/* Ensure filename is null-terminated */

-	AppState->HTTPServer.FileName[sizeof(AppState->HTTPServer.FileName) - 1] = 0x00;

-	

-	/* Determine the length of the URI so that it can be checked to see if it is a directory */

-	uint8_t FileNameLen = strlen(AppState->HTTPServer.FileName);

-

-	/* If the URI is a directory, append the default filename */

-	if (AppState->HTTPServer.FileName[FileNameLen - 1] == '/')

-	{

-		strncpy_P(&AppState->HTTPServer.FileName[FileNameLen], DefaultDirFileName,

-		          (sizeof(AppState->HTTPServer.FileName) - FileNameLen));

-

-		/* Ensure altered filename is still null-terminated */

-		AppState->HTTPServer.FileName[sizeof(AppState->HTTPServer.FileName) - 1] = 0x00;

-	}

-	

-	/* Try to open the file from the Dataflash disk */

-	AppState->HTTPServer.FileOpen     = (f_open(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.FileName,

-	                                            (FA_OPEN_EXISTING | FA_READ)) == FR_OK);

-

-	/* Lock to the SendResponseHeader state until connection terminated */

-	AppState->HTTPServer.CurrentState = WEBSERVER_STATE_SendResponseHeader;

-	AppState->HTTPServer.NextState    = WEBSERVER_STATE_SendResponseHeader;

-}

-

-/** HTTP Server State handler for the HTTP Response Header Send state. This state manages the transmission of

- *  the HTTP response header to the receiving HTTP client.

- */

-static void HTTPServerApp_SendResponseHeader(void)

-{

-	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;

-	char*               const AppData     = (char*)uip_appdata;

-

-	char* Extension     = strpbrk(AppState->HTTPServer.FileName, ".");

-	bool  FoundMIMEType = false;

-

-	/* If the file isn't already open, it wasn't found - send back a 404 error response and abort */

-	if (!(AppState->HTTPServer.FileOpen))

-	{

-		/* Copy over the HTTP 404 response header and send it to the receiving client */

-		strcpy_P(AppData, HTTP404Header);

-		strcpy(&AppData[strlen(AppData)], AppState->HTTPServer.FileName);		

-		uip_send(AppData, strlen(AppData));

-		

-		AppState->HTTPServer.NextState = WEBSERVER_STATE_Closing;

-		return;

-	}

-	

-	/* Copy over the HTTP 200 response header and send it to the receiving client */

-	strcpy_P(AppData, HTTP200Header);

-

-	/* Check to see if a MIME type for the requested file's extension was found */

-	if (Extension != NULL)

-	{

-		/* Look through the MIME type list, copy over the required MIME type if found */

-		for (uint8_t i = 0; i < (sizeof(MIMETypes) / sizeof(MIMETypes[0])); i++)

-		{

-			if (strcmp(&Extension[1], MIMETypes[i].Extension) == 0)

-			{

-				strcpy(&AppData[strlen(AppData)], MIMETypes[i].MIMEType);						

-				FoundMIMEType = true;

-				break;

-			}

-		} 

-	}

-

-	/* Check if a MIME type was found and copied to the output buffer */

-	if (!(FoundMIMEType))

-	{

-		/* MIME type not found - copy over the default MIME type */

-		strcpy_P(&AppData[strlen(AppData)], DefaultMIMEType);

-	}

-	

-	/* Add the end-of-line terminator and end-of-headers terminator after the MIME type */

-	strcpy_P(&AppData[strlen(AppData)], PSTR("\r\n\r\n"));

-	

-	/* Send the MIME header to the receiving client */

-	uip_send(AppData, strlen(AppData));

-	

-	/* When the MIME header is ACKed, progress to the data send stage */

-	AppState->HTTPServer.NextState = WEBSERVER_STATE_SendData;

-}

-

-/** HTTP Server State handler for the Data Send state. This state manages the transmission of file chunks

- *  to the receiving HTTP client.

- */

-static void HTTPServerApp_SendData(void)

-{

-	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;

-	char*               const AppData     = (char*)uip_appdata;

-

-	/* Get the maximum segment size for the current packet */

-	uint16_t MaxChunkSize = uip_mss();

-

-	/* Read the next chunk of data from the open file */

-	f_read(&AppState->HTTPServer.FileHandle, AppData, MaxChunkSize, &AppState->HTTPServer.SentChunkSize);

-	

-	/* Send the next file chunk to the receiving client */

-	uip_send(AppData, AppState->HTTPServer.SentChunkSize);

-			

-	/* Check if we are at the last chunk of the file, if so next ACK should close the connection */

-	if (MaxChunkSize != AppState->HTTPServer.SentChunkSize)

-	  AppState->HTTPServer.NextState = WEBSERVER_STATE_Closing;

-}

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  Simple HTTP Webserver Application. When connected to the uIP stack,
+ *  this will serve out files to HTTP clients on port 80.
+ */
+ 
+#define  INCLUDE_FROM_HTTPSERVERAPP_C
+#include "HTTPServerApp.h"
+
+/** HTTP server response header, for transmission before the page contents. This indicates to the host that a page exists at the
+ *  given location, and gives extra connection information.
+ */
+const char PROGMEM HTTP200Header[] = "HTTP/1.1 200 OK\r\n"
+                                     "Server: LUFA " LUFA_VERSION_STRING "\r\n"
+                                     "Connection: close\r\n"
+                                     "MIME-version: 1.0\r\n"
+                                     "Content-Type: ";
+
+/** HTTP server response header, for transmission before a resource not found error. This indicates to the host that the given
+ *  given URL is invalid, and gives extra error information.
+ */
+const char PROGMEM HTTP404Header[] = "HTTP/1.1 404 Not Found\r\n"
+                                     "Server: LUFA " LUFA_VERSION_STRING "\r\n"
+                                     "Connection: close\r\n"
+                                     "MIME-version: 1.0\r\n"
+                                     "Content-Type: text/plain\r\n\r\n"
+                                     "Error 404: File Not Found: /";
+
+/** Default filename to fetch when a directory is requested */
+const char PROGMEM DefaultDirFileName[] = "index.htm";
+
+/** Default MIME type sent if no other MIME type can be determined. */
+const char PROGMEM DefaultMIMEType[] = "text/plain";
+
+/** List of MIME types for each supported file extension. */
+const MIME_Type_t MIMETypes[] =
+	{
+		{.Extension = "htm", .MIMEType = "text/html"},
+		{.Extension = "jpg", .MIMEType = "image/jpeg"},
+		{.Extension = "gif", .MIMEType = "image/gif"},
+		{.Extension = "bmp", .MIMEType = "image/bmp"},
+		{.Extension = "png", .MIMEType = "image/png"},
+		{.Extension = "ico", .MIMEType = "image/x-icon"},
+		{.Extension = "exe", .MIMEType = "application/octet-stream"},
+		{.Extension = "gz",  .MIMEType = "application/x-gzip"},
+		{.Extension = "zip", .MIMEType = "application/zip"},
+		{.Extension = "pdf", .MIMEType = "application/pdf"},
+	};
+
+/** FATFs structure to hold the internal state of the FAT driver for the dataflash contents. */
+FATFS DiskFATState;
+
+
+/** Initialization function for the simple HTTP webserver. */
+void HTTPServerApp_Init(void)
+{
+	/* Listen on port 80 for HTTP connections from hosts */
+	uip_listen(HTONS(HTTP_SERVER_PORT));
+	
+	/* Mount the dataflash disk via FatFS */
+	f_mount(0, &DiskFATState);
+}
+
+/** uIP stack application callback for the simple HTTP webserver. This function must be called each time the
+ *  TCP/IP stack needs a TCP packet to be processed.
+ */
+void HTTPServerApp_Callback(void)
+{
+	uip_tcp_appstate_t* const AppState = &uip_conn->appstate;
+
+	if (uip_aborted() || uip_timedout() || uip_closed())
+	{
+		/* Lock to the closed state so that no further processing will occur on the connection */
+		AppState->HTTPServer.CurrentState  = WEBSERVER_STATE_Closing;
+		AppState->HTTPServer.NextState     = WEBSERVER_STATE_Closing;
+	}
+
+	if (uip_connected())
+	{
+		/* New connection - initialize connection state values */
+		AppState->HTTPServer.CurrentState  = WEBSERVER_STATE_OpenRequestedFile;
+		AppState->HTTPServer.NextState     = WEBSERVER_STATE_OpenRequestedFile;
+		AppState->HTTPServer.FileOpen      = false;
+		AppState->HTTPServer.ACKedFilePos  = 0;
+		AppState->HTTPServer.SentChunkSize = 0;
+	}
+
+	if (uip_acked())
+	{
+		/* Add the amount of ACKed file data to the total sent file bytes counter */
+		AppState->HTTPServer.ACKedFilePos += AppState->HTTPServer.SentChunkSize;
+
+		/* Progress to the next state once the current state's data has been ACKed */
+		AppState->HTTPServer.CurrentState = AppState->HTTPServer.NextState;
+	}
+
+	if (uip_rexmit())
+	{
+		/* Return file pointer to the last ACKed position */
+		f_lseek(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.ACKedFilePos);	
+	}
+
+	if (uip_rexmit() || uip_acked() || uip_newdata() || uip_connected() || uip_poll())
+	{
+		switch (AppState->HTTPServer.CurrentState)
+		{
+			case WEBSERVER_STATE_OpenRequestedFile:
+				HTTPServerApp_OpenRequestedFile();
+				break;
+			case WEBSERVER_STATE_SendResponseHeader:
+				HTTPServerApp_SendResponseHeader();
+				break;
+			case WEBSERVER_STATE_SendData:
+				HTTPServerApp_SendData();
+				break;
+			case WEBSERVER_STATE_Closing:
+				/* Connection is being terminated for some reason - close file handle */
+				f_close(&AppState->HTTPServer.FileHandle);
+				AppState->HTTPServer.FileOpen = false;
+		
+				/* If connection is not already closed, close it */
+				uip_close();
+				
+				AppState->HTTPServer.CurrentState = WEBSERVER_STATE_Closed;
+				AppState->HTTPServer.NextState    = WEBSERVER_STATE_Closed;
+				break;
+		}		  
+	}		
+}
+
+/** HTTP Server State handler for the Request Process state. This state manages the processing of incoming HTTP
+ *  GET requests to the server from the receiving HTTP client.
+ */
+static void HTTPServerApp_OpenRequestedFile(void)
+{
+	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
+	char*               const AppData     = (char*)uip_appdata;
+	
+	/* No HTTP header received from the client, abort processing */
+	if (!(uip_newdata()))
+	  return;
+	  
+	char* RequestToken      = strtok(AppData, " ");
+	char* RequestedFileName = strtok(NULL, " ");
+			
+	/* Must be a GET request, abort otherwise */
+	if (strcmp_P(RequestToken, PSTR("GET")) != 0)
+	{
+		uip_abort();
+		return;
+	}
+	
+	/* Copy over the requested filename */
+	strncpy(AppState->HTTPServer.FileName, &RequestedFileName[1], (sizeof(AppState->HTTPServer.FileName) - 1));
+	
+	/* Ensure filename is null-terminated */
+	AppState->HTTPServer.FileName[sizeof(AppState->HTTPServer.FileName) - 1] = 0x00;
+	
+	/* Determine the length of the URI so that it can be checked to see if it is a directory */
+	uint8_t FileNameLen = strlen(AppState->HTTPServer.FileName);
+
+	/* If the URI is a directory, append the default filename */
+	if (AppState->HTTPServer.FileName[FileNameLen - 1] == '/')
+	{
+		strncpy_P(&AppState->HTTPServer.FileName[FileNameLen], DefaultDirFileName,
+		          (sizeof(AppState->HTTPServer.FileName) - FileNameLen));
+
+		/* Ensure altered filename is still null-terminated */
+		AppState->HTTPServer.FileName[sizeof(AppState->HTTPServer.FileName) - 1] = 0x00;
+	}
+	
+	/* Try to open the file from the Dataflash disk */
+	AppState->HTTPServer.FileOpen     = (f_open(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.FileName,
+	                                            (FA_OPEN_EXISTING | FA_READ)) == FR_OK);
+
+	/* Lock to the SendResponseHeader state until connection terminated */
+	AppState->HTTPServer.CurrentState = WEBSERVER_STATE_SendResponseHeader;
+	AppState->HTTPServer.NextState    = WEBSERVER_STATE_SendResponseHeader;
+}
+
+/** HTTP Server State handler for the HTTP Response Header Send state. This state manages the transmission of
+ *  the HTTP response header to the receiving HTTP client.
+ */
+static void HTTPServerApp_SendResponseHeader(void)
+{
+	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
+	char*               const AppData     = (char*)uip_appdata;
+
+	char* Extension     = strpbrk(AppState->HTTPServer.FileName, ".");
+	bool  FoundMIMEType = false;
+
+	/* If the file isn't already open, it wasn't found - send back a 404 error response and abort */
+	if (!(AppState->HTTPServer.FileOpen))
+	{
+		/* Copy over the HTTP 404 response header and send it to the receiving client */
+		strcpy_P(AppData, HTTP404Header);
+		strcpy(&AppData[strlen(AppData)], AppState->HTTPServer.FileName);		
+		uip_send(AppData, strlen(AppData));
+		
+		AppState->HTTPServer.NextState = WEBSERVER_STATE_Closing;
+		return;
+	}
+	
+	/* Copy over the HTTP 200 response header and send it to the receiving client */
+	strcpy_P(AppData, HTTP200Header);
+
+	/* Check to see if a MIME type for the requested file's extension was found */
+	if (Extension != NULL)
+	{
+		/* Look through the MIME type list, copy over the required MIME type if found */
+		for (uint8_t i = 0; i < (sizeof(MIMETypes) / sizeof(MIMETypes[0])); i++)
+		{
+			if (strcmp(&Extension[1], MIMETypes[i].Extension) == 0)
+			{
+				strcpy(&AppData[strlen(AppData)], MIMETypes[i].MIMEType);						
+				FoundMIMEType = true;
+				break;
+			}
+		} 
+	}
+
+	/* Check if a MIME type was found and copied to the output buffer */
+	if (!(FoundMIMEType))
+	{
+		/* MIME type not found - copy over the default MIME type */
+		strcpy_P(&AppData[strlen(AppData)], DefaultMIMEType);
+	}
+	
+	/* Add the end-of-line terminator and end-of-headers terminator after the MIME type */
+	strcpy_P(&AppData[strlen(AppData)], PSTR("\r\n\r\n"));
+	
+	/* Send the MIME header to the receiving client */
+	uip_send(AppData, strlen(AppData));
+	
+	/* When the MIME header is ACKed, progress to the data send stage */
+	AppState->HTTPServer.NextState = WEBSERVER_STATE_SendData;
+}
+
+/** HTTP Server State handler for the Data Send state. This state manages the transmission of file chunks
+ *  to the receiving HTTP client.
+ */
+static void HTTPServerApp_SendData(void)
+{
+	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;
+	char*               const AppData     = (char*)uip_appdata;
+
+	/* Get the maximum segment size for the current packet */
+	uint16_t MaxChunkSize = uip_mss();
+
+	/* Read the next chunk of data from the open file */
+	f_read(&AppState->HTTPServer.FileHandle, AppData, MaxChunkSize, &AppState->HTTPServer.SentChunkSize);
+	
+	/* Send the next file chunk to the receiving client */
+	uip_send(AppData, AppState->HTTPServer.SentChunkSize);
+			
+	/* Check if we are at the last chunk of the file, if so next ACK should close the connection */
+	if (MaxChunkSize != AppState->HTTPServer.SentChunkSize)
+	  AppState->HTTPServer.NextState = WEBSERVER_STATE_Closing;
+}
diff --git a/Projects/Webserver/Lib/HTTPServerApp.h b/Projects/Webserver/Lib/HTTPServerApp.h
index 47b810845..04cdbe5fe 100644
--- a/Projects/Webserver/Lib/HTTPServerApp.h
+++ b/Projects/Webserver/Lib/HTTPServerApp.h
@@ -1,81 +1,81 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-/** \file

- *

- *  Header file for HTTPServerApp.c.

- */

-

-#ifndef _HTTPSERVER_APP_H_

-#define _HTTPSERVER_APP_H_

-

-	/* Includes: */

-		#include <avr/pgmspace.h>

-		#include <string.h>

-		

-		#include <LUFA/Version.h>

-

-		#include <uip.h>

-		#include <ff.h>

-	

-	/* Enums: */

-		/** States for each HTTP connection to the webserver. */

-		enum Webserver_States_t

-		{

-			WEBSERVER_STATE_OpenRequestedFile, /**< Currently opening requested file */

-			WEBSERVER_STATE_SendResponseHeader, /**< Currently sending HTTP response headers to the client */

-			WEBSERVER_STATE_SendData, /**< Currently sending HTTP page data to the client */

-			WEBSERVER_STATE_Closing, /**< Ready to close the connection to the client */

-			WEBSERVER_STATE_Closed, /**< Connection closed after all data sent */

-		};

-		

-	/* Type Defines: */

-		/** Type define for a MIME type handler. */

-		typedef struct

-		{

-			char* Extension; /**< File extension (no leading '.' character) */

-			char* MIMEType;  /**< Appropriate MIME type to send when the extension is encountered */

-		} MIME_Type_t;

-	

-	/* Macros: */

-		/** TCP listen port for incoming HTTP traffic */

-		#define HTTP_SERVER_PORT  80

-

-	/* Function Prototypes: */

-		void HTTPServerApp_Init(void);

-		void HTTPServerApp_Callback(void);

-		

-		#if defined(INCLUDE_FROM_HTTPSERVERAPP_C)

-			static void HTTPServerApp_OpenRequestedFile(void);

-			static void HTTPServerApp_SendResponseHeader(void);

-			static void HTTPServerApp_SendData(void);

-		#endif

-		

-#endif

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  Header file for HTTPServerApp.c.
+ */
+
+#ifndef _HTTPSERVER_APP_H_
+#define _HTTPSERVER_APP_H_
+
+	/* Includes: */
+		#include <avr/pgmspace.h>
+		#include <string.h>
+		
+		#include <LUFA/Version.h>
+
+		#include <uip.h>
+		#include <ff.h>
+	
+	/* Enums: */
+		/** States for each HTTP connection to the webserver. */
+		enum Webserver_States_t
+		{
+			WEBSERVER_STATE_OpenRequestedFile, /**< Currently opening requested file */
+			WEBSERVER_STATE_SendResponseHeader, /**< Currently sending HTTP response headers to the client */
+			WEBSERVER_STATE_SendData, /**< Currently sending HTTP page data to the client */
+			WEBSERVER_STATE_Closing, /**< Ready to close the connection to the client */
+			WEBSERVER_STATE_Closed, /**< Connection closed after all data sent */
+		};
+		
+	/* Type Defines: */
+		/** Type define for a MIME type handler. */
+		typedef struct
+		{
+			char* Extension; /**< File extension (no leading '.' character) */
+			char* MIMEType;  /**< Appropriate MIME type to send when the extension is encountered */
+		} MIME_Type_t;
+	
+	/* Macros: */
+		/** TCP listen port for incoming HTTP traffic */
+		#define HTTP_SERVER_PORT  80
+
+	/* Function Prototypes: */
+		void HTTPServerApp_Init(void);
+		void HTTPServerApp_Callback(void);
+		
+		#if defined(INCLUDE_FROM_HTTPSERVERAPP_C)
+			static void HTTPServerApp_OpenRequestedFile(void);
+			static void HTTPServerApp_SendResponseHeader(void);
+			static void HTTPServerApp_SendData(void);
+		#endif
+		
+#endif
diff --git a/Projects/Webserver/Lib/SCSI.c b/Projects/Webserver/Lib/SCSI.c
index 8a376a41b..55312e87b 100644
--- a/Projects/Webserver/Lib/SCSI.c
+++ b/Projects/Webserver/Lib/SCSI.c
@@ -1,281 +1,281 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-/** \file

- *

- *  SCSI command processing routines, for SCSI commands issued by the host. Mass Storage

- *  devices use a thin "Bulk-Only Transport" protocol for issuing commands and status information,

- *  which wrap around standard SCSI device commands for controlling the actual storage medium.

- */

- 

-#define  INCLUDE_FROM_SCSI_C

-#include "SCSI.h"

-

-/** Structure to hold the SCSI response data to a SCSI INQUIRY command. This gives information about the device's

- *  features and capabilities.

- */

-SCSI_Inquiry_Response_t InquiryData = 

-	{

-		.DeviceType          = DEVICE_TYPE_BLOCK,

-		.PeripheralQualifier = 0,

-			

-		.Removable           = true,

-			

-		.Version             = 0,

-			

-		.ResponseDataFormat  = 2,

-		.NormACA             = false,

-		.TrmTsk              = false,

-		.AERC                = false,

-

-		.AdditionalLength    = 0x1F,

-			

-		.SoftReset           = false,

-		.CmdQue              = false,

-		.Linked              = false,

-		.Sync                = false,

-		.WideBus16Bit        = false,

-		.WideBus32Bit        = false,

-		.RelAddr             = false,

-		

-		.VendorID            = "LUFA",

-		.ProductID           = "Dataflash Disk",

-		.RevisionID          = {'0','.','0','0'},

-	};

-

-/** Structure to hold the sense data for the last issued SCSI command, which is returned to the host after a SCSI REQUEST SENSE

- *  command is issued. This gives information on exactly why the last command failed to complete.

- */

-SCSI_Request_Sense_Response_t SenseData =

-	{

-		.ResponseCode        = 0x70,

-		.AdditionalLength    = 0x0A,

-	};

-

-

-/** Main routine to process the SCSI command located in the Command Block Wrapper read from the host. This dispatches

- *  to the appropriate SCSI command handling routine if the issued command is supported by the device, else it returns

- *  a command failure due to a ILLEGAL REQUEST.

- *

- *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

- */

-bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)

-{

-	/* Set initial sense data, before the requested command is processed */

-	SCSI_SET_SENSE(SCSI_SENSE_KEY_GOOD,

-	               SCSI_ASENSE_NO_ADDITIONAL_INFORMATION,

-	               SCSI_ASENSEQ_NO_QUALIFIER);

-					   

-	/* Run the appropriate SCSI command hander function based on the passed command */

-	switch (MSInterfaceInfo->State.CommandBlock.SCSICommandData[0])

-	{

-		case SCSI_CMD_INQUIRY:

-			SCSI_Command_Inquiry(MSInterfaceInfo);			

-			break;

-		case SCSI_CMD_REQUEST_SENSE:

-			SCSI_Command_Request_Sense(MSInterfaceInfo);

-			break;

-		case SCSI_CMD_READ_CAPACITY_10:

-			SCSI_Command_Read_Capacity_10(MSInterfaceInfo);			

-			break;

-		case SCSI_CMD_SEND_DIAGNOSTIC:

-			SCSI_Command_Send_Diagnostic(MSInterfaceInfo);

-			break;

-		case SCSI_CMD_WRITE_10:

-			SCSI_Command_ReadWrite_10(MSInterfaceInfo, DATA_WRITE);

-			break;

-		case SCSI_CMD_READ_10:

-			SCSI_Command_ReadWrite_10(MSInterfaceInfo, DATA_READ);

-			break;

-		case SCSI_CMD_TEST_UNIT_READY:

-		case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:

-		case SCSI_CMD_VERIFY_10:

-			/* These commands should just succeed, no handling required */

-			MSInterfaceInfo->State.CommandBlock.DataTransferLength = 0;

-			break;

-		default:

-			/* Update the SENSE key to reflect the invalid command */

-			SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,

-		                   SCSI_ASENSE_INVALID_COMMAND,

-		                   SCSI_ASENSEQ_NO_QUALIFIER);

-			break;

-	}

-

-	return (SenseData.SenseKey == SCSI_SENSE_KEY_GOOD);

-}

-

-/** Command processing for an issued SCSI INQUIRY command. This command returns information about the device's features

- *  and capabilities to the host.

- *

- *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

- */

-static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)

-{

-	uint16_t AllocationLength  = (((uint16_t)MSInterfaceInfo->State.CommandBlock.SCSICommandData[3] << 8) |

-	                                         MSInterfaceInfo->State.CommandBlock.SCSICommandData[4]);

-	uint16_t BytesTransferred  = (AllocationLength < sizeof(InquiryData))? AllocationLength :

-	                                                                       sizeof(InquiryData);

-

-	/* Only the standard INQUIRY data is supported, check if any optional INQUIRY bits set */

-	if ((MSInterfaceInfo->State.CommandBlock.SCSICommandData[1] & ((1 << 0) | (1 << 1))) ||

-	     MSInterfaceInfo->State.CommandBlock.SCSICommandData[2])

-	{

-		/* Optional but unsupported bits set - update the SENSE key and fail the request */

-		SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,

-		               SCSI_ASENSE_INVALID_FIELD_IN_CDB,

-		               SCSI_ASENSEQ_NO_QUALIFIER);

-

-		return;

-	}

-	

-	Endpoint_Write_Stream_LE(&InquiryData, BytesTransferred, NO_STREAM_CALLBACK);

-

-	uint8_t PadBytes[AllocationLength - BytesTransferred];

-	

-	/* Pad out remaining bytes with 0x00 */

-	Endpoint_Write_Stream_LE(&PadBytes, (AllocationLength - BytesTransferred), NO_STREAM_CALLBACK);

-

-	/* Finalize the stream transfer to send the last packet */

-	Endpoint_ClearIN();

-

-	/* Succeed the command and update the bytes transferred counter */

-	MSInterfaceInfo->State.CommandBlock.DataTransferLength -= BytesTransferred;

-}

-

-/** Command processing for an issued SCSI REQUEST SENSE command. This command returns information about the last issued command,

- *  including the error code and additional error information so that the host can determine why a command failed to complete.

- *

- *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

- */

-static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)

-{

-	uint8_t  AllocationLength = MSInterfaceInfo->State.CommandBlock.SCSICommandData[4];

-	uint8_t  BytesTransferred = (AllocationLength < sizeof(SenseData))? AllocationLength : sizeof(SenseData);

-	

-	uint8_t PadBytes[AllocationLength - BytesTransferred];

-

-	Endpoint_Write_Stream_LE(&SenseData, BytesTransferred, NO_STREAM_CALLBACK);

-	Endpoint_Write_Stream_LE(&PadBytes, (AllocationLength - BytesTransferred), NO_STREAM_CALLBACK);

-	Endpoint_ClearIN();

-

-	/* Succeed the command and update the bytes transferred counter */

-	MSInterfaceInfo->State.CommandBlock.DataTransferLength -= BytesTransferred;

-}

-

-/** Command processing for an issued SCSI READ CAPACITY (10) command. This command returns information about the device's capacity

- *  on the selected Logical Unit (drive), as a number of OS-sized blocks.

- *

- *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

- */

-static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)

-{

-	uint32_t LastBlockAddressInLUN = (VIRTUAL_MEMORY_BLOCKS - 1);

-	uint32_t MediaBlockSize        = VIRTUAL_MEMORY_BLOCK_SIZE;

-

-	Endpoint_Write_Stream_BE(&LastBlockAddressInLUN, sizeof(LastBlockAddressInLUN), NO_STREAM_CALLBACK);

-	Endpoint_Write_Stream_BE(&MediaBlockSize, sizeof(MediaBlockSize), NO_STREAM_CALLBACK);

-	Endpoint_ClearIN();

-	

-	/* Succeed the command and update the bytes transferred counter */

-	MSInterfaceInfo->State.CommandBlock.DataTransferLength -= 8;

-}

-

-/** Command processing for an issued SCSI SEND DIAGNOSTIC command. This command performs a quick check of the Dataflash ICs on the

- *  board, and indicates if they are present and functioning correctly. Only the Self-Test portion of the diagnostic command is

- *  supported.

- *

- *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

- */

-static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)

-{

-	/* Check to see if the SELF TEST bit is not set */

-	if (!(MSInterfaceInfo->State.CommandBlock.SCSICommandData[1] & (1 << 2)))

-	{

-		/* Only self-test supported - update SENSE key and fail the command */

-		SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,

-		               SCSI_ASENSE_INVALID_FIELD_IN_CDB,

-		               SCSI_ASENSEQ_NO_QUALIFIER);

-

-		return;

-	}

-	

-	/* Check to see if all attached Dataflash ICs are functional */

-	if (!(DataflashManager_CheckDataflashOperation()))

-	{

-		/* Update SENSE key with a hardware error condition and return command fail */

-		SCSI_SET_SENSE(SCSI_SENSE_KEY_HARDWARE_ERROR,

-		               SCSI_ASENSE_NO_ADDITIONAL_INFORMATION,

-		               SCSI_ASENSEQ_NO_QUALIFIER);	

-	

-		return;

-	}

-	

-	/* Succeed the command and update the bytes transferred counter */

-	MSInterfaceInfo->State.CommandBlock.DataTransferLength = 0;

-}

-

-/** Command processing for an issued SCSI READ (10) or WRITE (10) command. This command reads in the block start address

- *  and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual

- *  reading and writing of the data.

- *

- *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

- *  \param[in] IsDataRead  Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE)

- */

-static void SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const bool IsDataRead)

-{

-	uint32_t BlockAddress;

-	uint16_t TotalBlocks;

-	

-	/* Load in the 32-bit block address (SCSI uses big-endian, so have to reverse the byte order) */

-	BlockAddress = SwapEndian_32(*(uint32_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[2]);

-

-	/* Load in the 16-bit total blocks (SCSI uses big-endian, so have to reverse the byte order) */

-	TotalBlocks  = SwapEndian_16(*(uint32_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[7]);

-	

-	/* Check if the block address is outside the maximum allowable value for the LUN */

-	if (BlockAddress >= VIRTUAL_MEMORY_BLOCKS)

-	{

-		/* Block address is invalid, update SENSE key and return command fail */

-		SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,

-		               SCSI_ASENSE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE,

-		               SCSI_ASENSEQ_NO_QUALIFIER);

-

-		return;

-	}

-	

-	/* Determine if the packet is a READ (10) or WRITE (10) command, call appropriate function */

-	if (IsDataRead == DATA_READ)

-	  DataflashManager_ReadBlocks(MSInterfaceInfo, BlockAddress, TotalBlocks);

-	else

-	  DataflashManager_WriteBlocks(MSInterfaceInfo, BlockAddress, TotalBlocks);

-

-	/* Update the bytes transferred counter and succeed the command */

-	MSInterfaceInfo->State.CommandBlock.DataTransferLength -= ((uint32_t)TotalBlocks * VIRTUAL_MEMORY_BLOCK_SIZE);

-}

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  SCSI command processing routines, for SCSI commands issued by the host. Mass Storage
+ *  devices use a thin "Bulk-Only Transport" protocol for issuing commands and status information,
+ *  which wrap around standard SCSI device commands for controlling the actual storage medium.
+ */
+ 
+#define  INCLUDE_FROM_SCSI_C
+#include "SCSI.h"
+
+/** Structure to hold the SCSI response data to a SCSI INQUIRY command. This gives information about the device's
+ *  features and capabilities.
+ */
+SCSI_Inquiry_Response_t InquiryData = 
+	{
+		.DeviceType          = DEVICE_TYPE_BLOCK,
+		.PeripheralQualifier = 0,
+			
+		.Removable           = true,
+			
+		.Version             = 0,
+			
+		.ResponseDataFormat  = 2,
+		.NormACA             = false,
+		.TrmTsk              = false,
+		.AERC                = false,
+
+		.AdditionalLength    = 0x1F,
+			
+		.SoftReset           = false,
+		.CmdQue              = false,
+		.Linked              = false,
+		.Sync                = false,
+		.WideBus16Bit        = false,
+		.WideBus32Bit        = false,
+		.RelAddr             = false,
+		
+		.VendorID            = "LUFA",
+		.ProductID           = "Dataflash Disk",
+		.RevisionID          = {'0','.','0','0'},
+	};
+
+/** Structure to hold the sense data for the last issued SCSI command, which is returned to the host after a SCSI REQUEST SENSE
+ *  command is issued. This gives information on exactly why the last command failed to complete.
+ */
+SCSI_Request_Sense_Response_t SenseData =
+	{
+		.ResponseCode        = 0x70,
+		.AdditionalLength    = 0x0A,
+	};
+
+
+/** Main routine to process the SCSI command located in the Command Block Wrapper read from the host. This dispatches
+ *  to the appropriate SCSI command handling routine if the issued command is supported by the device, else it returns
+ *  a command failure due to a ILLEGAL REQUEST.
+ *
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with
+ */
+bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
+{
+	/* Set initial sense data, before the requested command is processed */
+	SCSI_SET_SENSE(SCSI_SENSE_KEY_GOOD,
+	               SCSI_ASENSE_NO_ADDITIONAL_INFORMATION,
+	               SCSI_ASENSEQ_NO_QUALIFIER);
+					   
+	/* Run the appropriate SCSI command hander function based on the passed command */
+	switch (MSInterfaceInfo->State.CommandBlock.SCSICommandData[0])
+	{
+		case SCSI_CMD_INQUIRY:
+			SCSI_Command_Inquiry(MSInterfaceInfo);			
+			break;
+		case SCSI_CMD_REQUEST_SENSE:
+			SCSI_Command_Request_Sense(MSInterfaceInfo);
+			break;
+		case SCSI_CMD_READ_CAPACITY_10:
+			SCSI_Command_Read_Capacity_10(MSInterfaceInfo);			
+			break;
+		case SCSI_CMD_SEND_DIAGNOSTIC:
+			SCSI_Command_Send_Diagnostic(MSInterfaceInfo);
+			break;
+		case SCSI_CMD_WRITE_10:
+			SCSI_Command_ReadWrite_10(MSInterfaceInfo, DATA_WRITE);
+			break;
+		case SCSI_CMD_READ_10:
+			SCSI_Command_ReadWrite_10(MSInterfaceInfo, DATA_READ);
+			break;
+		case SCSI_CMD_TEST_UNIT_READY:
+		case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
+		case SCSI_CMD_VERIFY_10:
+			/* These commands should just succeed, no handling required */
+			MSInterfaceInfo->State.CommandBlock.DataTransferLength = 0;
+			break;
+		default:
+			/* Update the SENSE key to reflect the invalid command */
+			SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,
+		                   SCSI_ASENSE_INVALID_COMMAND,
+		                   SCSI_ASENSEQ_NO_QUALIFIER);
+			break;
+	}
+
+	return (SenseData.SenseKey == SCSI_SENSE_KEY_GOOD);
+}
+
+/** Command processing for an issued SCSI INQUIRY command. This command returns information about the device's features
+ *  and capabilities to the host.
+ *
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with
+ */
+static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
+{
+	uint16_t AllocationLength  = (((uint16_t)MSInterfaceInfo->State.CommandBlock.SCSICommandData[3] << 8) |
+	                                         MSInterfaceInfo->State.CommandBlock.SCSICommandData[4]);
+	uint16_t BytesTransferred  = (AllocationLength < sizeof(InquiryData))? AllocationLength :
+	                                                                       sizeof(InquiryData);
+
+	/* Only the standard INQUIRY data is supported, check if any optional INQUIRY bits set */
+	if ((MSInterfaceInfo->State.CommandBlock.SCSICommandData[1] & ((1 << 0) | (1 << 1))) ||
+	     MSInterfaceInfo->State.CommandBlock.SCSICommandData[2])
+	{
+		/* Optional but unsupported bits set - update the SENSE key and fail the request */
+		SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,
+		               SCSI_ASENSE_INVALID_FIELD_IN_CDB,
+		               SCSI_ASENSEQ_NO_QUALIFIER);
+
+		return;
+	}
+	
+	Endpoint_Write_Stream_LE(&InquiryData, BytesTransferred, NO_STREAM_CALLBACK);
+
+	uint8_t PadBytes[AllocationLength - BytesTransferred];
+	
+	/* Pad out remaining bytes with 0x00 */
+	Endpoint_Write_Stream_LE(&PadBytes, (AllocationLength - BytesTransferred), NO_STREAM_CALLBACK);
+
+	/* Finalize the stream transfer to send the last packet */
+	Endpoint_ClearIN();
+
+	/* Succeed the command and update the bytes transferred counter */
+	MSInterfaceInfo->State.CommandBlock.DataTransferLength -= BytesTransferred;
+}
+
+/** Command processing for an issued SCSI REQUEST SENSE command. This command returns information about the last issued command,
+ *  including the error code and additional error information so that the host can determine why a command failed to complete.
+ *
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with
+ */
+static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
+{
+	uint8_t  AllocationLength = MSInterfaceInfo->State.CommandBlock.SCSICommandData[4];
+	uint8_t  BytesTransferred = (AllocationLength < sizeof(SenseData))? AllocationLength : sizeof(SenseData);
+	
+	uint8_t PadBytes[AllocationLength - BytesTransferred];
+
+	Endpoint_Write_Stream_LE(&SenseData, BytesTransferred, NO_STREAM_CALLBACK);
+	Endpoint_Write_Stream_LE(&PadBytes, (AllocationLength - BytesTransferred), NO_STREAM_CALLBACK);
+	Endpoint_ClearIN();
+
+	/* Succeed the command and update the bytes transferred counter */
+	MSInterfaceInfo->State.CommandBlock.DataTransferLength -= BytesTransferred;
+}
+
+/** Command processing for an issued SCSI READ CAPACITY (10) command. This command returns information about the device's capacity
+ *  on the selected Logical Unit (drive), as a number of OS-sized blocks.
+ *
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with
+ */
+static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
+{
+	uint32_t LastBlockAddressInLUN = (VIRTUAL_MEMORY_BLOCKS - 1);
+	uint32_t MediaBlockSize        = VIRTUAL_MEMORY_BLOCK_SIZE;
+
+	Endpoint_Write_Stream_BE(&LastBlockAddressInLUN, sizeof(LastBlockAddressInLUN), NO_STREAM_CALLBACK);
+	Endpoint_Write_Stream_BE(&MediaBlockSize, sizeof(MediaBlockSize), NO_STREAM_CALLBACK);
+	Endpoint_ClearIN();
+	
+	/* Succeed the command and update the bytes transferred counter */
+	MSInterfaceInfo->State.CommandBlock.DataTransferLength -= 8;
+}
+
+/** Command processing for an issued SCSI SEND DIAGNOSTIC command. This command performs a quick check of the Dataflash ICs on the
+ *  board, and indicates if they are present and functioning correctly. Only the Self-Test portion of the diagnostic command is
+ *  supported.
+ *
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with
+ */
+static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
+{
+	/* Check to see if the SELF TEST bit is not set */
+	if (!(MSInterfaceInfo->State.CommandBlock.SCSICommandData[1] & (1 << 2)))
+	{
+		/* Only self-test supported - update SENSE key and fail the command */
+		SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,
+		               SCSI_ASENSE_INVALID_FIELD_IN_CDB,
+		               SCSI_ASENSEQ_NO_QUALIFIER);
+
+		return;
+	}
+	
+	/* Check to see if all attached Dataflash ICs are functional */
+	if (!(DataflashManager_CheckDataflashOperation()))
+	{
+		/* Update SENSE key with a hardware error condition and return command fail */
+		SCSI_SET_SENSE(SCSI_SENSE_KEY_HARDWARE_ERROR,
+		               SCSI_ASENSE_NO_ADDITIONAL_INFORMATION,
+		               SCSI_ASENSEQ_NO_QUALIFIER);	
+	
+		return;
+	}
+	
+	/* Succeed the command and update the bytes transferred counter */
+	MSInterfaceInfo->State.CommandBlock.DataTransferLength = 0;
+}
+
+/** Command processing for an issued SCSI READ (10) or WRITE (10) command. This command reads in the block start address
+ *  and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual
+ *  reading and writing of the data.
+ *
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with
+ *  \param[in] IsDataRead  Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE)
+ */
+static void SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const bool IsDataRead)
+{
+	uint32_t BlockAddress;
+	uint16_t TotalBlocks;
+	
+	/* Load in the 32-bit block address (SCSI uses big-endian, so have to reverse the byte order) */
+	BlockAddress = SwapEndian_32(*(uint32_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[2]);
+
+	/* Load in the 16-bit total blocks (SCSI uses big-endian, so have to reverse the byte order) */
+	TotalBlocks  = SwapEndian_16(*(uint32_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[7]);
+	
+	/* Check if the block address is outside the maximum allowable value for the LUN */
+	if (BlockAddress >= VIRTUAL_MEMORY_BLOCKS)
+	{
+		/* Block address is invalid, update SENSE key and return command fail */
+		SCSI_SET_SENSE(SCSI_SENSE_KEY_ILLEGAL_REQUEST,
+		               SCSI_ASENSE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE,
+		               SCSI_ASENSEQ_NO_QUALIFIER);
+
+		return;
+	}
+	
+	/* Determine if the packet is a READ (10) or WRITE (10) command, call appropriate function */
+	if (IsDataRead == DATA_READ)
+	  DataflashManager_ReadBlocks(MSInterfaceInfo, BlockAddress, TotalBlocks);
+	else
+	  DataflashManager_WriteBlocks(MSInterfaceInfo, BlockAddress, TotalBlocks);
+
+	/* Update the bytes transferred counter and succeed the command */
+	MSInterfaceInfo->State.CommandBlock.DataTransferLength -= ((uint32_t)TotalBlocks * VIRTUAL_MEMORY_BLOCK_SIZE);
+}
diff --git a/Projects/Webserver/Lib/SCSI.h b/Projects/Webserver/Lib/SCSI.h
index 196b5f689..e83f59bfc 100644
--- a/Projects/Webserver/Lib/SCSI.h
+++ b/Projects/Webserver/Lib/SCSI.h
@@ -1,85 +1,85 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-/** \file

- *

- *  Header file for SCSI.c.

- */

- 

-#ifndef _SCSI_H_

-#define _SCSI_H_

-

-	/* Includes: */

-		#include <avr/io.h>

-		#include <avr/pgmspace.h>

-

-		#include <LUFA/Drivers/USB/USB.h>

-		#include <LUFA/Drivers/USB/Class/MassStorage.h>

-

-		#include "../Descriptors.h"

-		#include "DataflashManager.h"

-	

-	/* Macros: */

-		/** Macro to set the current SCSI sense data to the given key, additional sense code and additional sense qualifier. This

-		 *  is for convenience, as it allows for all three sense values (returned upon request to the host to give information about

-		 *  the last command failure) in a quick and easy manner.

-		 *

-		 *  \param[in] key    New SCSI sense key to set the sense code to

-		 *  \param[in] acode  New SCSI additional sense key to set the additional sense code to

-		 *  \param[in] aqual  New SCSI additional sense key qualifier to set the additional sense qualifier code to

-		 */

-		#define SCSI_SET_SENSE(key, acode, aqual)  MACROS{ SenseData.SenseKey = (key);                   \

-		                                                   SenseData.AdditionalSenseCode = (acode);      \

-		                                                   SenseData.AdditionalSenseQualifier = (aqual); }MACROE

-

-		/** Macro for the SCSI_Command_ReadWrite_10() function, to indicate that data is to be read from the storage medium. */

-		#define DATA_READ           true

-

-		/** Macro for the SCSI_Command_ReadWrite_10() function, to indicate that data is to be written to the storage medium. */

-		#define DATA_WRITE          false

-

-		/** Value for the DeviceType entry in the SCSI_Inquiry_Response_t enum, indicating a Block Media device. */

-		#define DEVICE_TYPE_BLOCK   0x00

-		

-		/** Value for the DeviceType entry in the SCSI_Inquiry_Response_t enum, indicating a CD-ROM device. */

-		#define DEVICE_TYPE_CDROM   0x05

-		

-	/* Function Prototypes: */

-		bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

-		

-		#if defined(INCLUDE_FROM_SCSI_C)

-			static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

-			static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

-			static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

-			static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

-			static void SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const bool IsDataRead);

-		#endif

-		

-#endif

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  Header file for SCSI.c.
+ */
+ 
+#ifndef _SCSI_H_
+#define _SCSI_H_
+
+	/* Includes: */
+		#include <avr/io.h>
+		#include <avr/pgmspace.h>
+
+		#include <LUFA/Drivers/USB/USB.h>
+		#include <LUFA/Drivers/USB/Class/MassStorage.h>
+
+		#include "../Descriptors.h"
+		#include "DataflashManager.h"
+	
+	/* Macros: */
+		/** Macro to set the current SCSI sense data to the given key, additional sense code and additional sense qualifier. This
+		 *  is for convenience, as it allows for all three sense values (returned upon request to the host to give information about
+		 *  the last command failure) in a quick and easy manner.
+		 *
+		 *  \param[in] key    New SCSI sense key to set the sense code to
+		 *  \param[in] acode  New SCSI additional sense key to set the additional sense code to
+		 *  \param[in] aqual  New SCSI additional sense key qualifier to set the additional sense qualifier code to
+		 */
+		#define SCSI_SET_SENSE(key, acode, aqual)  MACROS{ SenseData.SenseKey = (key);                   \
+		                                                   SenseData.AdditionalSenseCode = (acode);      \
+		                                                   SenseData.AdditionalSenseQualifier = (aqual); }MACROE
+
+		/** Macro for the SCSI_Command_ReadWrite_10() function, to indicate that data is to be read from the storage medium. */
+		#define DATA_READ           true
+
+		/** Macro for the SCSI_Command_ReadWrite_10() function, to indicate that data is to be written to the storage medium. */
+		#define DATA_WRITE          false
+
+		/** Value for the DeviceType entry in the SCSI_Inquiry_Response_t enum, indicating a Block Media device. */
+		#define DEVICE_TYPE_BLOCK   0x00
+		
+		/** Value for the DeviceType entry in the SCSI_Inquiry_Response_t enum, indicating a CD-ROM device. */
+		#define DEVICE_TYPE_CDROM   0x05
+		
+	/* Function Prototypes: */
+		bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
+		
+		#if defined(INCLUDE_FROM_SCSI_C)
+			static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
+			static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
+			static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
+			static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
+			static void SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const bool IsDataRead);
+		#endif
+		
+#endif
diff --git a/Projects/Webserver/Lib/TELNETServerApp.c b/Projects/Webserver/Lib/TELNETServerApp.c
index 2855f8d76..da9108676 100644
--- a/Projects/Webserver/Lib/TELNETServerApp.c
+++ b/Projects/Webserver/Lib/TELNETServerApp.c
@@ -1,162 +1,162 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-#if defined(ENABLE_TELNET_SERVER) || defined(__DOXYGEN__)

-

-/** \file

- *

- *  TELNET Webserver Application. When connected to the uIP stack,

- *  this will serve out raw TELNET to the client on port 23.

- */

- 

-#define  INCLUDE_FROM_TELNETSERVERAPP_C

-#include "TELNETServerApp.h"

-

-/** Welcome message to send to a TELNET client when a connection is first made. */

-const char PROGMEM WelcomeHeader[] = "********************************************\r\n"

-                                     "*       LUFA uIP Webserver (TELNET)        *\r\n"

-                                     "********************************************\r\n";

-

-/** Main TELNET menu, giving the user the list of available commands they may issue */

-const char PROGMEM TELNETMenu[] = "\r\n"

-                                  "  == Available Commands: ==\r\n"

-                                  "     c) List Active TCP Connections\r\n"

-                                  "  =========================\r\n"

-                                  "\r\n>";

-								  

-/** Header to print before the current connections are printed to the client */

-const char PROGMEM CurrentConnectionsHeader[] = "\r\n* Current TCP Connections: *\r\n";

-

-/** Initialization function for the simple HTTP webserver. */

-void TELNETServerApp_Init(void)

-{

-	/* Listen on port 23 for TELNET connections from hosts */

-	uip_listen(HTONS(TELNET_SERVER_PORT));

-}

-

-/** uIP stack application callback for the TELNET server. This function must be called each time the

- *  TCP/IP stack needs a TCP packet to be processed.

- */

-void TELNETServerApp_Callback(void)

-{

-	uip_tcp_appstate_t* const AppState   = &uip_conn->appstate;

-	char*               const AppData    = (char*)uip_appdata;

-

-	if (uip_connected())

-	{

-		/* New connection - initialize connection state values */

-		AppState->TELNETServer.CurrentState = TELNET_STATE_SendHeader;

-	}

-

-	if (uip_acked())

-	{

-		/* Progress to the next state once the current state's data has been ACKed */

-		AppState->TELNETServer.CurrentState = AppState->TELNETServer.NextState;	

-	}

-

-	if (uip_rexmit() || uip_acked() || uip_newdata() || uip_connected() || uip_poll())

-	{

-		switch (AppState->TELNETServer.CurrentState)

-		{

-			case TELNET_STATE_SendHeader:

-				/* Copy over and send the TELNET welcome message upon first connection */

-				strcpy_P(AppData, WelcomeHeader);

-				uip_send(AppData, strlen(AppData));

-				

-				AppState->TELNETServer.NextState = TELNET_STATE_SendMenu;

-				break;

-			case TELNET_STATE_SendMenu:

-				/* Copy over and send the TELNET menu to the client */

-				strcpy_P(AppData, TELNETMenu);

-				uip_send(AppData, strlen(AppData));

-				

-				AppState->TELNETServer.NextState = TELNET_STATE_GetCommand;

-				break;

-			case TELNET_STATE_GetCommand:

-				if (!(uip_datalen()))

-				  break;

-

-				/* Save the issued command for later processing */

-				AppState->TELNETServer.IssuedCommand = AppData[0];

- 

-				AppState->TELNETServer.CurrentState  = TELNET_STATE_SendResponse;

-				break;

-			case TELNET_STATE_SendResponse:

-				/* Determine which command was issued, perform command processing */

-				switch (AppState->TELNETServer.IssuedCommand)

-				{

-					case 'c':

-						TELNETServerApp_DisplayTCPConnections();

-						break;

-					default:

-						strcpy_P(AppData, PSTR("Invalid Command.\r\n"));

-						uip_send(AppData, strlen(AppData));

-						break;

-				}

-

-				AppState->TELNETServer.NextState = TELNET_STATE_SendMenu;

-				break;

-		}

-	}		

-}

-

-/** Sends a list of active TCP connections to the TELNET client. */

-static void TELNETServerApp_DisplayTCPConnections(void)

-{

-	char* const AppData    = (char*)uip_appdata;

-

-	strcpy_P(AppData, CurrentConnectionsHeader);

-							

-	uint16_t ResponseLen     = strlen(AppData);

-	uint8_t  ActiveConnCount = 0;

-

-	/* Loop through the complete uIP TCP connections list, looking for active connections */

-	for (uint8_t i = 0; i < UIP_CONNS; i++)

-	{

-		struct uip_conn* CurrConnection = &uip_conns[i];

-		

-		/* If the connection is not closed, it is active and must be added to the out buffer */

-		if (CurrConnection->tcpstateflags != UIP_CLOSED)

-		{

-			/* Add the current connection's details to the out buffer */

-			ResponseLen += sprintf_P(&AppData[ResponseLen], PSTR("%u) %02d.%02d.%02d.%02d (Local %u, Remote %u)\r\n"),

-			                         ++ActiveConnCount,

-			                         CurrConnection->ripaddr.u8[0],

-			                         CurrConnection->ripaddr.u8[1],

-			                         CurrConnection->ripaddr.u8[2],

-			                         CurrConnection->ripaddr.u8[3],

-			                         HTONS(CurrConnection->lport), HTONS(CurrConnection->rport));

-		}

-	}

-

-	uip_send(AppData, ResponseLen);

-}

-

-#endif

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+#if defined(ENABLE_TELNET_SERVER) || defined(__DOXYGEN__)
+
+/** \file
+ *
+ *  TELNET Webserver Application. When connected to the uIP stack,
+ *  this will serve out raw TELNET to the client on port 23.
+ */
+ 
+#define  INCLUDE_FROM_TELNETSERVERAPP_C
+#include "TELNETServerApp.h"
+
+/** Welcome message to send to a TELNET client when a connection is first made. */
+const char PROGMEM WelcomeHeader[] = "********************************************\r\n"
+                                     "*       LUFA uIP Webserver (TELNET)        *\r\n"
+                                     "********************************************\r\n";
+
+/** Main TELNET menu, giving the user the list of available commands they may issue */
+const char PROGMEM TELNETMenu[] = "\r\n"
+                                  "  == Available Commands: ==\r\n"
+                                  "     c) List Active TCP Connections\r\n"
+                                  "  =========================\r\n"
+                                  "\r\n>";
+								  
+/** Header to print before the current connections are printed to the client */
+const char PROGMEM CurrentConnectionsHeader[] = "\r\n* Current TCP Connections: *\r\n";
+
+/** Initialization function for the simple HTTP webserver. */
+void TELNETServerApp_Init(void)
+{
+	/* Listen on port 23 for TELNET connections from hosts */
+	uip_listen(HTONS(TELNET_SERVER_PORT));
+}
+
+/** uIP stack application callback for the TELNET server. This function must be called each time the
+ *  TCP/IP stack needs a TCP packet to be processed.
+ */
+void TELNETServerApp_Callback(void)
+{
+	uip_tcp_appstate_t* const AppState   = &uip_conn->appstate;
+	char*               const AppData    = (char*)uip_appdata;
+
+	if (uip_connected())
+	{
+		/* New connection - initialize connection state values */
+		AppState->TELNETServer.CurrentState = TELNET_STATE_SendHeader;
+	}
+
+	if (uip_acked())
+	{
+		/* Progress to the next state once the current state's data has been ACKed */
+		AppState->TELNETServer.CurrentState = AppState->TELNETServer.NextState;	
+	}
+
+	if (uip_rexmit() || uip_acked() || uip_newdata() || uip_connected() || uip_poll())
+	{
+		switch (AppState->TELNETServer.CurrentState)
+		{
+			case TELNET_STATE_SendHeader:
+				/* Copy over and send the TELNET welcome message upon first connection */
+				strcpy_P(AppData, WelcomeHeader);
+				uip_send(AppData, strlen(AppData));
+				
+				AppState->TELNETServer.NextState = TELNET_STATE_SendMenu;
+				break;
+			case TELNET_STATE_SendMenu:
+				/* Copy over and send the TELNET menu to the client */
+				strcpy_P(AppData, TELNETMenu);
+				uip_send(AppData, strlen(AppData));
+				
+				AppState->TELNETServer.NextState = TELNET_STATE_GetCommand;
+				break;
+			case TELNET_STATE_GetCommand:
+				if (!(uip_datalen()))
+				  break;
+
+				/* Save the issued command for later processing */
+				AppState->TELNETServer.IssuedCommand = AppData[0];
+ 
+				AppState->TELNETServer.CurrentState  = TELNET_STATE_SendResponse;
+				break;
+			case TELNET_STATE_SendResponse:
+				/* Determine which command was issued, perform command processing */
+				switch (AppState->TELNETServer.IssuedCommand)
+				{
+					case 'c':
+						TELNETServerApp_DisplayTCPConnections();
+						break;
+					default:
+						strcpy_P(AppData, PSTR("Invalid Command.\r\n"));
+						uip_send(AppData, strlen(AppData));
+						break;
+				}
+
+				AppState->TELNETServer.NextState = TELNET_STATE_SendMenu;
+				break;
+		}
+	}		
+}
+
+/** Sends a list of active TCP connections to the TELNET client. */
+static void TELNETServerApp_DisplayTCPConnections(void)
+{
+	char* const AppData    = (char*)uip_appdata;
+
+	strcpy_P(AppData, CurrentConnectionsHeader);
+							
+	uint16_t ResponseLen     = strlen(AppData);
+	uint8_t  ActiveConnCount = 0;
+
+	/* Loop through the complete uIP TCP connections list, looking for active connections */
+	for (uint8_t i = 0; i < UIP_CONNS; i++)
+	{
+		struct uip_conn* CurrConnection = &uip_conns[i];
+		
+		/* If the connection is not closed, it is active and must be added to the out buffer */
+		if (CurrConnection->tcpstateflags != UIP_CLOSED)
+		{
+			/* Add the current connection's details to the out buffer */
+			ResponseLen += sprintf_P(&AppData[ResponseLen], PSTR("%u) %02d.%02d.%02d.%02d (Local %u, Remote %u)\r\n"),
+			                         ++ActiveConnCount,
+			                         CurrConnection->ripaddr.u8[0],
+			                         CurrConnection->ripaddr.u8[1],
+			                         CurrConnection->ripaddr.u8[2],
+			                         CurrConnection->ripaddr.u8[3],
+			                         HTONS(CurrConnection->lport), HTONS(CurrConnection->rport));
+		}
+	}
+
+	uip_send(AppData, ResponseLen);
+}
+
+#endif
diff --git a/Projects/Webserver/Lib/TELNETServerApp.h b/Projects/Webserver/Lib/TELNETServerApp.h
index ff34d1482..c42725763 100644
--- a/Projects/Webserver/Lib/TELNETServerApp.h
+++ b/Projects/Webserver/Lib/TELNETServerApp.h
@@ -1,68 +1,68 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-/** \file

- *

- *  Header file for TELNETServerApp.c.

- */

-

-#ifndef _TELNETSERVER_APP_H_

-#define _TELNETSERVER_APP_H_

-

-	/* Includes: */

-		#include <avr/pgmspace.h>

-		#include <string.h>

-		#include <stdio.h>

-		

-		#include <uip.h>

-	

-	/* Macros: */

-		/** TCP listen port for incoming TELNET traffic */

-		#define TELNET_SERVER_PORT  23

-		

-	/* Enums: */

-		/** States for each TELNET connection to the server. */

-		enum TELNET_States_t

-		{

-			TELNET_STATE_SendHeader, /**< Currently sending welcome header to the client */

-			TELNET_STATE_SendMenu, /**< Currently sending the command list menu to the client */

-			TELNET_STATE_GetCommand, /**< Currently waiting for a command from the client */

-			TELNET_STATE_SendResponse, /**< Processing the issued command and sending a response */

-		};	

-

-	/* Function Prototypes: */

-		void TELNETServerApp_Init(void);

-		void TELNETServerApp_Callback(void);

-		

-		#if defined(INCLUDE_FROM_TELNETSERVERAPP_C)

-			static void TELNETServerApp_DisplayTCPConnections(void);

-		#endif

-		

-#endif

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  Header file for TELNETServerApp.c.
+ */
+
+#ifndef _TELNETSERVER_APP_H_
+#define _TELNETSERVER_APP_H_
+
+	/* Includes: */
+		#include <avr/pgmspace.h>
+		#include <string.h>
+		#include <stdio.h>
+		
+		#include <uip.h>
+	
+	/* Macros: */
+		/** TCP listen port for incoming TELNET traffic */
+		#define TELNET_SERVER_PORT  23
+		
+	/* Enums: */
+		/** States for each TELNET connection to the server. */
+		enum TELNET_States_t
+		{
+			TELNET_STATE_SendHeader, /**< Currently sending welcome header to the client */
+			TELNET_STATE_SendMenu, /**< Currently sending the command list menu to the client */
+			TELNET_STATE_GetCommand, /**< Currently waiting for a command from the client */
+			TELNET_STATE_SendResponse, /**< Processing the issued command and sending a response */
+		};	
+
+	/* Function Prototypes: */
+		void TELNETServerApp_Init(void);
+		void TELNETServerApp_Callback(void);
+		
+		#if defined(INCLUDE_FROM_TELNETSERVERAPP_C)
+			static void TELNETServerApp_DisplayTCPConnections(void);
+		#endif
+		
+#endif
diff --git a/Projects/Webserver/Lib/uIPManagement.c b/Projects/Webserver/Lib/uIPManagement.c
index 45f8a6ae5..2d1a93130 100644
--- a/Projects/Webserver/Lib/uIPManagement.c
+++ b/Projects/Webserver/Lib/uIPManagement.c
@@ -1,251 +1,251 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-/** \file

- *

- *  uIP Management functions. This file contains the functions and globals needed to maintain the uIP

- *  stack once an RNDIS device has been attached to the system.

- */

-

-#define  INCLUDE_FROM_UIPMANAGEMENT_C

-#include "uIPManagement.h"

-

-/** Connection timer, to retain the time elapsed since the last time the uIP connections were managed. */

-struct timer ConnectionTimer;

-

-/** ARP timer, to retain the time elapsed since the ARP cache was last updated. */

-struct timer ARPTimer;

-

-/** MAC address of the RNDIS device, when enumerated */

-struct uip_eth_addr MACAddress;

-

-bool HaveIPConfiguration;

-

-/** Configures the uIP stack ready for network traffic. */

-void uIPManagement_Init(void)

-{

-	/* uIP Timing Initialization */

-	clock_init();

-	timer_set(&ConnectionTimer, CLOCK_SECOND / 2);

-	timer_set(&ARPTimer, CLOCK_SECOND * 10);	

-

-	/* uIP Stack Initialization */

-	uip_init();

-	uip_arp_init();

-	uip_setethaddr(MACAddress);

-

-	/* DHCP/Server IP Settings Initialization */

-	#if defined(ENABLE_DHCP_CLIENT)

-	HaveIPConfiguration = false;

-	DHCPClientApp_Init();

-	#else

-	HaveIPConfiguration = true;

-	uip_ipaddr_t IPAddress, Netmask, GatewayIPAddress;

-	uip_ipaddr(&IPAddress,        DEVICE_IP_ADDRESS[0], DEVICE_IP_ADDRESS[1], DEVICE_IP_ADDRESS[2], DEVICE_IP_ADDRESS[3]);

-	uip_ipaddr(&Netmask,          DEVICE_NETMASK[0],    DEVICE_NETMASK[1],    DEVICE_NETMASK[2],    DEVICE_NETMASK[3]);

-	uip_ipaddr(&GatewayIPAddress, DEVICE_GATEWAY[0],    DEVICE_GATEWAY[1],    DEVICE_GATEWAY[2],    DEVICE_GATEWAY[3]);

-	uip_sethostaddr(&IPAddress);

-	uip_setnetmask(&Netmask);

-	uip_setdraddr(&GatewayIPAddress);

-	#endif

-	

-	/* HTTP Webserver Initialization */

-	HTTPServerApp_Init();

-	

-	/* TELNET Server Initialization */

-	#if defined(ENABLE_TELNET_SERVER)

-	TELNETServerApp_Init();

-	#endif

-}

-

-/** uIP Management function. This function manages the uIP stack when called while an RNDIS device has been

- *  attached to the system.

- */

-void uIPManagement_ManageNetwork(void)

-{

-	if ((USB_CurrentMode == USB_MODE_HOST) && (USB_HostState == HOST_STATE_Configured))

-	{

-		uIPManagement_ProcessIncomingPacket();

-		uIPManagement_ManageConnections();

-	}

-}

-

-/** uIP TCP/IP network stack callback function for the processing of a given TCP connection. This routine dispatches

- *  to the appropriate TCP protocol application based on the connection's listen port number.

- */

-void uIPManagement_TCPCallback(void)

-{

-	/* Call the correct TCP application based on the port number the connection is listening on */

-	switch (uip_conn->lport)

-	{

-		case HTONS(HTTP_SERVER_PORT):

-			HTTPServerApp_Callback();

-			break;

-		#if defined(ENABLE_TELNET_SERVER)

-		case HTONS(TELNET_SERVER_PORT):

-			TELNETServerApp_Callback();

-			break;

-		#endif

-	}

-}

-

-/** uIP TCP/IP network stack callback function for the processing of a given UDP connection. This routine dispatches

- *  to the appropriate UDP protocol application based on the connection's listen port number.

- */

-void uIPManagement_UDPCallback(void)

-{

-	/* Call the correct UDP application based on the port number the connection is listening on */

-	switch (uip_udp_conn->lport)

-	{

-		case HTONS(DHCPC_CLIENT_PORT):

-			DHCPClientApp_Callback();

-			break;

-	}

-}

-

-/** Processes Incoming packets to the server from the connected RNDIS device, creating responses as needed. */

-static void uIPManagement_ProcessIncomingPacket(void)

-{

-	/* If no packet received, exit processing routine */

-	if (!(RNDIS_Host_IsPacketReceived(&Ethernet_RNDIS_Interface)))

-	  return;

-	  

-	LEDs_SetAllLEDs(LEDMASK_USB_BUSY);

-

-	/* Read the Incoming packet straight into the UIP packet buffer */

-	RNDIS_Host_ReadPacket(&Ethernet_RNDIS_Interface, uip_buf, &uip_len);

-

-	/* If the packet contains an Ethernet frame, process it */

-	if (uip_len > 0)

-	{

-		switch (((struct uip_eth_hdr*)uip_buf)->type)

-		{

-			case HTONS(UIP_ETHTYPE_IP):

-				/* Filter packet by MAC destination */

-				uip_arp_ipin();

-

-				/* Process Incoming packet */

-				uip_input();

-

-				/* If a response was generated, send it */

-				if (uip_len > 0)

-				{

-					/* Add destination MAC to outgoing packet */

-					uip_arp_out();

-

-					uip_split_output();

-				}

-				

-				break;

-			case HTONS(UIP_ETHTYPE_ARP):

-				/* Process ARP packet */

-				uip_arp_arpin();

-				

-				/* If a response was generated, send it */

-				if (uip_len > 0)

-				  uip_split_output();

-				

-				break;

-		}

-	}

-

-	LEDs_SetAllLEDs(LEDMASK_USB_READY | ((HaveIPConfiguration) ? LEDMASK_UIP_READY_CONFIG : LEDMASK_UIP_READY_NOCONFIG));

-}

-

-/** Manages the currently open network connections, including TCP and (if enabled) UDP. */

-static void uIPManagement_ManageConnections(void)

-{

-	/* Poll TCP connections for more data to send back to the host */

-	for (uint8_t i = 0; i < UIP_CONNS; i++)

-	{

-		uip_poll_conn(&uip_conns[i]);

-

-		/* If a response was generated, send it */

-		if (uip_len > 0)

-		{

-			/* Add destination MAC to outgoing packet */

-			uip_arp_out();

-

-			/* Split and send the outgoing packet */

-			uip_split_output();

-		}

-	}

-

-	/* Manage open connections for timeouts */

-	if (timer_expired(&ConnectionTimer))

-	{

-		timer_reset(&ConnectionTimer);

-

-		LEDs_SetAllLEDs(LEDMASK_USB_BUSY);

-		

-		for (uint8_t i = 0; i < UIP_CONNS; i++)

-		{

-			/* Run periodic connection management for each TCP connection */

-			uip_periodic(i);

-

-			/* If a response was generated, send it */

-			if (uip_len > 0)

-			{

-				/* Add destination MAC to outgoing packet */

-				uip_arp_out();

-

-				/* Split and send the outgoing packet */

-				uip_split_output();

-			}

-		}

-		

-		#if defined(ENABLE_DHCP_CLIENT)

-		for (uint8_t i = 0; i < UIP_UDP_CONNS; i++)

-		{

-			/* Run periodic connection management for each UDP connection */

-			uip_udp_periodic(i);

-

-			/* If a response was generated, send it */

-			if (uip_len > 0)

-			{

-				/* Add destination MAC to outgoing packet */

-				uip_arp_out();

-

-				/* Split and send the outgoing packet */

-				uip_split_output();

-			}

-		}

-		#endif

-

-		LEDs_SetAllLEDs(LEDMASK_USB_READY);

-	}

-

-	/* Manage ARP cache refreshing */

-	if (timer_expired(&ARPTimer))

-	{

-		timer_reset(&ARPTimer);

-		uip_arp_timer();

-	}

-}

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  uIP Management functions. This file contains the functions and globals needed to maintain the uIP
+ *  stack once an RNDIS device has been attached to the system.
+ */
+
+#define  INCLUDE_FROM_UIPMANAGEMENT_C
+#include "uIPManagement.h"
+
+/** Connection timer, to retain the time elapsed since the last time the uIP connections were managed. */
+struct timer ConnectionTimer;
+
+/** ARP timer, to retain the time elapsed since the ARP cache was last updated. */
+struct timer ARPTimer;
+
+/** MAC address of the RNDIS device, when enumerated */
+struct uip_eth_addr MACAddress;
+
+bool HaveIPConfiguration;
+
+/** Configures the uIP stack ready for network traffic. */
+void uIPManagement_Init(void)
+{
+	/* uIP Timing Initialization */
+	clock_init();
+	timer_set(&ConnectionTimer, CLOCK_SECOND / 2);
+	timer_set(&ARPTimer, CLOCK_SECOND * 10);	
+
+	/* uIP Stack Initialization */
+	uip_init();
+	uip_arp_init();
+	uip_setethaddr(MACAddress);
+
+	/* DHCP/Server IP Settings Initialization */
+	#if defined(ENABLE_DHCP_CLIENT)
+	HaveIPConfiguration = false;
+	DHCPClientApp_Init();
+	#else
+	HaveIPConfiguration = true;
+	uip_ipaddr_t IPAddress, Netmask, GatewayIPAddress;
+	uip_ipaddr(&IPAddress,        DEVICE_IP_ADDRESS[0], DEVICE_IP_ADDRESS[1], DEVICE_IP_ADDRESS[2], DEVICE_IP_ADDRESS[3]);
+	uip_ipaddr(&Netmask,          DEVICE_NETMASK[0],    DEVICE_NETMASK[1],    DEVICE_NETMASK[2],    DEVICE_NETMASK[3]);
+	uip_ipaddr(&GatewayIPAddress, DEVICE_GATEWAY[0],    DEVICE_GATEWAY[1],    DEVICE_GATEWAY[2],    DEVICE_GATEWAY[3]);
+	uip_sethostaddr(&IPAddress);
+	uip_setnetmask(&Netmask);
+	uip_setdraddr(&GatewayIPAddress);
+	#endif
+	
+	/* HTTP Webserver Initialization */
+	HTTPServerApp_Init();
+	
+	/* TELNET Server Initialization */
+	#if defined(ENABLE_TELNET_SERVER)
+	TELNETServerApp_Init();
+	#endif
+}
+
+/** uIP Management function. This function manages the uIP stack when called while an RNDIS device has been
+ *  attached to the system.
+ */
+void uIPManagement_ManageNetwork(void)
+{
+	if ((USB_CurrentMode == USB_MODE_HOST) && (USB_HostState == HOST_STATE_Configured))
+	{
+		uIPManagement_ProcessIncomingPacket();
+		uIPManagement_ManageConnections();
+	}
+}
+
+/** uIP TCP/IP network stack callback function for the processing of a given TCP connection. This routine dispatches
+ *  to the appropriate TCP protocol application based on the connection's listen port number.
+ */
+void uIPManagement_TCPCallback(void)
+{
+	/* Call the correct TCP application based on the port number the connection is listening on */
+	switch (uip_conn->lport)
+	{
+		case HTONS(HTTP_SERVER_PORT):
+			HTTPServerApp_Callback();
+			break;
+		#if defined(ENABLE_TELNET_SERVER)
+		case HTONS(TELNET_SERVER_PORT):
+			TELNETServerApp_Callback();
+			break;
+		#endif
+	}
+}
+
+/** uIP TCP/IP network stack callback function for the processing of a given UDP connection. This routine dispatches
+ *  to the appropriate UDP protocol application based on the connection's listen port number.
+ */
+void uIPManagement_UDPCallback(void)
+{
+	/* Call the correct UDP application based on the port number the connection is listening on */
+	switch (uip_udp_conn->lport)
+	{
+		case HTONS(DHCPC_CLIENT_PORT):
+			DHCPClientApp_Callback();
+			break;
+	}
+}
+
+/** Processes Incoming packets to the server from the connected RNDIS device, creating responses as needed. */
+static void uIPManagement_ProcessIncomingPacket(void)
+{
+	/* If no packet received, exit processing routine */
+	if (!(RNDIS_Host_IsPacketReceived(&Ethernet_RNDIS_Interface)))
+	  return;
+	  
+	LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
+
+	/* Read the Incoming packet straight into the UIP packet buffer */
+	RNDIS_Host_ReadPacket(&Ethernet_RNDIS_Interface, uip_buf, &uip_len);
+
+	/* If the packet contains an Ethernet frame, process it */
+	if (uip_len > 0)
+	{
+		switch (((struct uip_eth_hdr*)uip_buf)->type)
+		{
+			case HTONS(UIP_ETHTYPE_IP):
+				/* Filter packet by MAC destination */
+				uip_arp_ipin();
+
+				/* Process Incoming packet */
+				uip_input();
+
+				/* If a response was generated, send it */
+				if (uip_len > 0)
+				{
+					/* Add destination MAC to outgoing packet */
+					uip_arp_out();
+
+					uip_split_output();
+				}
+				
+				break;
+			case HTONS(UIP_ETHTYPE_ARP):
+				/* Process ARP packet */
+				uip_arp_arpin();
+				
+				/* If a response was generated, send it */
+				if (uip_len > 0)
+				  uip_split_output();
+				
+				break;
+		}
+	}
+
+	LEDs_SetAllLEDs(LEDMASK_USB_READY | ((HaveIPConfiguration) ? LEDMASK_UIP_READY_CONFIG : LEDMASK_UIP_READY_NOCONFIG));
+}
+
+/** Manages the currently open network connections, including TCP and (if enabled) UDP. */
+static void uIPManagement_ManageConnections(void)
+{
+	/* Poll TCP connections for more data to send back to the host */
+	for (uint8_t i = 0; i < UIP_CONNS; i++)
+	{
+		uip_poll_conn(&uip_conns[i]);
+
+		/* If a response was generated, send it */
+		if (uip_len > 0)
+		{
+			/* Add destination MAC to outgoing packet */
+			uip_arp_out();
+
+			/* Split and send the outgoing packet */
+			uip_split_output();
+		}
+	}
+
+	/* Manage open connections for timeouts */
+	if (timer_expired(&ConnectionTimer))
+	{
+		timer_reset(&ConnectionTimer);
+
+		LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
+		
+		for (uint8_t i = 0; i < UIP_CONNS; i++)
+		{
+			/* Run periodic connection management for each TCP connection */
+			uip_periodic(i);
+
+			/* If a response was generated, send it */
+			if (uip_len > 0)
+			{
+				/* Add destination MAC to outgoing packet */
+				uip_arp_out();
+
+				/* Split and send the outgoing packet */
+				uip_split_output();
+			}
+		}
+		
+		#if defined(ENABLE_DHCP_CLIENT)
+		for (uint8_t i = 0; i < UIP_UDP_CONNS; i++)
+		{
+			/* Run periodic connection management for each UDP connection */
+			uip_udp_periodic(i);
+
+			/* If a response was generated, send it */
+			if (uip_len > 0)
+			{
+				/* Add destination MAC to outgoing packet */
+				uip_arp_out();
+
+				/* Split and send the outgoing packet */
+				uip_split_output();
+			}
+		}
+		#endif
+
+		LEDs_SetAllLEDs(LEDMASK_USB_READY);
+	}
+
+	/* Manage ARP cache refreshing */
+	if (timer_expired(&ARPTimer))
+	{
+		timer_reset(&ARPTimer);
+		uip_arp_timer();
+	}
+}
diff --git a/Projects/Webserver/Lib/uIPManagement.h b/Projects/Webserver/Lib/uIPManagement.h
index ed02374f5..37c54e9ad 100644
--- a/Projects/Webserver/Lib/uIPManagement.h
+++ b/Projects/Webserver/Lib/uIPManagement.h
@@ -1,79 +1,79 @@
-/*

-             LUFA Library

-     Copyright (C) Dean Camera, 2010.

-              

-  dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com

-*/

-

-/*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

-

-  Permission to use, copy, modify, distribute, and sell this 

-  software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 

-  all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 

-  documentation, and that the name of the author not be used in 

-  advertising or publicity pertaining to distribution of the 

-  software without specific, written prior permission.

-

-  The author disclaim all warranties with regard to this

-  software, including all implied warranties of merchantability

-  and fitness.  In no event shall the author be liable for any

-  special, indirect or consequential damages or any damages

-  whatsoever resulting from loss of use, data or profits, whether

-  in an action of contract, negligence or other tortious action,

-  arising out of or in connection with the use or performance of

-  this software.

-*/

-

-/** \file

- *

- *  Header file for uIPManagement.c.

- */

-

-#ifndef _UIP_MANAGEMENT_H_

-#define _UIP_MANAGEMENT_H_

-

-	/* Includes: */

-		#include <LUFA/Drivers/USB/Class/RNDIS.h>

-

-		#include <uip.h>

-		#include <uip_arp.h>

-		#include <uip-split.h>

-		#include <timer.h>

-		

-		#include "Lib/DHCPClientApp.h"

-		#include "Lib/HTTPServerApp.h"

-		#include "Lib/TELNETServerApp.h"

-		

-	/* Macros: */

-		/** IP address that the webserver should use once connected to a RNDIS device (when DHCP is disabled). */

-		#define DEVICE_IP_ADDRESS         (uint8_t[]){192, 168, 1, 10}

-		

-		/** Netmask that the webserver should once connected to a RNDIS device (when DHCP is disabled). */

-		#define DEVICE_NETMASK            (uint8_t[]){255, 255, 255, 0}

-		

-		/** IP address of the default gateway the webserver should use when routing outside the local subnet

-		 *  (when DHCP is disabled).

-		 */

-		#define DEVICE_GATEWAY            (uint8_t[]){192, 168, 1, 1}

-

-	/* External Variables: */

-		extern struct uip_eth_addr MACAddress;

-		

-		extern bool HaveIPConfiguration;

-		

-	/* Function Prototypes: */

-		void uIPManagement_Init(void);

-		void uIPManagement_ManageNetwork(void);

-		void uIPManagement_TCPCallback(void);

-		void uIPManagement_UDPCallback(void);

-		

-		#if defined(INCLUDE_FROM_UIPMANAGEMENT_C)

-			static void uIPManagement_ProcessIncomingPacket(void);

-			static void uIPManagement_ManageConnections(void);

-		#endif

-		

-#endif

+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2010.
+              
+  dean [at] fourwalledcubicle [dot] com
+      www.fourwalledcubicle.com
+*/
+
+/*
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this 
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in 
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting 
+  documentation, and that the name of the author not be used in 
+  advertising or publicity pertaining to distribution of the 
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  Header file for uIPManagement.c.
+ */
+
+#ifndef _UIP_MANAGEMENT_H_
+#define _UIP_MANAGEMENT_H_
+
+	/* Includes: */
+		#include <LUFA/Drivers/USB/Class/RNDIS.h>
+
+		#include <uip.h>
+		#include <uip_arp.h>
+		#include <uip-split.h>
+		#include <timer.h>
+		
+		#include "Lib/DHCPClientApp.h"
+		#include "Lib/HTTPServerApp.h"
+		#include "Lib/TELNETServerApp.h"
+		
+	/* Macros: */
+		/** IP address that the webserver should use once connected to a RNDIS device (when DHCP is disabled). */
+		#define DEVICE_IP_ADDRESS         (uint8_t[]){192, 168, 1, 10}
+		
+		/** Netmask that the webserver should once connected to a RNDIS device (when DHCP is disabled). */
+		#define DEVICE_NETMASK            (uint8_t[]){255, 255, 255, 0}
+		
+		/** IP address of the default gateway the webserver should use when routing outside the local subnet
+		 *  (when DHCP is disabled).
+		 */
+		#define DEVICE_GATEWAY            (uint8_t[]){192, 168, 1, 1}
+
+	/* External Variables: */
+		extern struct uip_eth_addr MACAddress;
+		
+		extern bool HaveIPConfiguration;
+		
+	/* Function Prototypes: */
+		void uIPManagement_Init(void);
+		void uIPManagement_ManageNetwork(void);
+		void uIPManagement_TCPCallback(void);
+		void uIPManagement_UDPCallback(void);
+		
+		#if defined(INCLUDE_FROM_UIPMANAGEMENT_C)
+			static void uIPManagement_ProcessIncomingPacket(void);
+			static void uIPManagement_ManageConnections(void);
+		#endif
+		
+#endif
diff --git a/Projects/Webserver/Lib/uip/clock.c b/Projects/Webserver/Lib/uip/clock.c
index 450714888..046b6e344 100644
--- a/Projects/Webserver/Lib/uip/clock.c
+++ b/Projects/Webserver/Lib/uip/clock.c
@@ -1,38 +1,38 @@
-#include <stdint.h>

-#include <stdlib.h>

-#include <stdio.h>

-#include <avr/interrupt.h>

-#include <avr/io.h>

-#include <avr/sfr_defs.h>

-

-#include "clock.h"

-

-//Counted time

-volatile clock_time_t clock_datetime = 0;

-

-//Overflow interrupt

-ISR(TIMER1_COMPA_vect)

-{

-	clock_datetime += 1;

-}

-

-//Initialise the clock

-void clock_init()

-{

-	OCR1A  = ((F_CPU / 1024) / 100);

-	TCCR1B = ((1 << WGM12) | (1 << CS12) | (1 << CS10));

-	TIMSK1 = (1 << OCIE1A);

-}

-

-//Return time

-clock_time_t clock_time()

-{

-	clock_time_t time;

-

-	ATOMIC_BLOCK(ATOMIC_FORCEON)

-	{

-		time = clock_datetime;

-	}

-

-	return time;

-}

+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <avr/interrupt.h>
+#include <avr/io.h>
+#include <avr/sfr_defs.h>
+
+#include "clock.h"
+
+//Counted time
+volatile clock_time_t clock_datetime = 0;
+
+//Overflow interrupt
+ISR(TIMER1_COMPA_vect)
+{
+	clock_datetime += 1;
+}
+
+//Initialise the clock
+void clock_init()
+{
+	OCR1A  = ((F_CPU / 1024) / 100);
+	TCCR1B = ((1 << WGM12) | (1 << CS12) | (1 << CS10));
+	TIMSK1 = (1 << OCIE1A);
+}
+
+//Return time
+clock_time_t clock_time()
+{
+	clock_time_t time;
+
+	ATOMIC_BLOCK(ATOMIC_FORCEON)
+	{
+		time = clock_datetime;
+	}
+
+	return time;
+}
diff --git a/Projects/Webserver/Lib/uip/clock.h b/Projects/Webserver/Lib/uip/clock.h
index b585f47aa..05d30386b 100644
--- a/Projects/Webserver/Lib/uip/clock.h
+++ b/Projects/Webserver/Lib/uip/clock.h
@@ -1,12 +1,12 @@
-#ifndef __CLOCK_ARCH_H__

-#define __CLOCK_ARCH_H__

-

-#include <stdint.h>

-#include <util/atomic.h>

-

-typedef uint16_t clock_time_t;

-#define CLOCK_SECOND 100

-void clock_init(void);

-clock_time_t clock_time(void);

-

-#endif /* __CLOCK_ARCH_H__ */

+#ifndef __CLOCK_ARCH_H__
+#define __CLOCK_ARCH_H__
+
+#include <stdint.h>
+#include <util/atomic.h>
+
+typedef uint16_t clock_time_t;
+#define CLOCK_SECOND 100
+void clock_init(void);
+clock_time_t clock_time(void);
+
+#endif /* __CLOCK_ARCH_H__ */
diff --git a/Projects/Webserver/Lib/uip/timer.c b/Projects/Webserver/Lib/uip/timer.c
index 8c270b233..74eedf611 100644
--- a/Projects/Webserver/Lib/uip/timer.c
+++ b/Projects/Webserver/Lib/uip/timer.c
@@ -1,127 +1,127 @@
-/**

- * \addtogroup timer

- * @{

- */

-

-/**

- * \file

- * Timer library implementation.

- * \author

- * Adam Dunkels <adam@sics.se>

- */

-

-/*

- * Copyright (c) 2004, Swedish Institute of Computer Science.

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- * 1. Redistributions of source code must retain the above copyright

- *    notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- *    notice, this list of conditions and the following disclaimer in the

- *    documentation and/or other materials provided with the distribution.

- * 3. Neither the name of the Institute nor the names of its contributors

- *    may be used to endorse or promote products derived from this software

- *    without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND

- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

- * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE

- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

- * SUCH DAMAGE.

- *

- * This file is part of the uIP TCP/IP stack

- *

- * Author: Adam Dunkels <adam@sics.se>

- *

- * $Id: timer.c,v 1.2 2006/06/12 08:00:30 adam Exp $

- */

-

-#include "clock.h"

-#include "timer.h"

-

-/*---------------------------------------------------------------------------*/

-/**

- * Set a timer.

- *

- * This function is used to set a timer for a time sometime in the

- * future. The function timer_expired() will evaluate to true after

- * the timer has expired.

- *

- * \param t A pointer to the timer

- * \param interval The interval before the timer expires.

- *

- */

-void

-timer_set(struct timer *t, clock_time_t interval)

-{

-  t->interval = interval;

-  t->start = clock_time();

-}

-/*---------------------------------------------------------------------------*/

-/**

- * Reset the timer with the same interval.

- *

- * This function resets the timer with the same interval that was

- * given to the timer_set() function. The start point of the interval

- * is the exact time that the timer last expired. Therefore, this

- * function will cause the timer to be stable over time, unlike the

- * timer_rester() function.

- *

- * \param t A pointer to the timer.

- *

- * \sa timer_restart()

- */

-void

-timer_reset(struct timer *t)

-{

-  t->start += t->interval;

-}

-/*---------------------------------------------------------------------------*/

-/**

- * Restart the timer from the current point in time

- *

- * This function restarts a timer with the same interval that was

- * given to the timer_set() function. The timer will start at the

- * current time.

- *

- * \note A periodic timer will drift if this function is used to reset

- * it. For preioric timers, use the timer_reset() function instead.

- *

- * \param t A pointer to the timer.

- *

- * \sa timer_reset()

- */

-void

-timer_restart(struct timer *t)

-{

-  t->start = clock_time();

-}

-/*---------------------------------------------------------------------------*/

-/**

- * Check if a timer has expired.

- *

- * This function tests if a timer has expired and returns true or

- * false depending on its status.

- *

- * \param t A pointer to the timer

- *

- * \return Non-zero if the timer has expired, zero otherwise.

- *

- */

-int

-timer_expired(struct timer *t)

-{

-  return (clock_time_t)(clock_time() - t->start) >= (clock_time_t)t->interval;

-}

-/*---------------------------------------------------------------------------*/

-

-/** @} */

+/**
+ * \addtogroup timer
+ * @{
+ */
+
+/**
+ * \file
+ * Timer library implementation.
+ * \author
+ * Adam Dunkels <adam@sics.se>
+ */
+
+/*
+ * Copyright (c) 2004, Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ * $Id: timer.c,v 1.2 2006/06/12 08:00:30 adam Exp $
+ */
+
+#include "clock.h"
+#include "timer.h"
+
+/*---------------------------------------------------------------------------*/
+/**
+ * Set a timer.
+ *
+ * This function is used to set a timer for a time sometime in the
+ * future. The function timer_expired() will evaluate to true after
+ * the timer has expired.
+ *
+ * \param t A pointer to the timer
+ * \param interval The interval before the timer expires.
+ *
+ */
+void
+timer_set(struct timer *t, clock_time_t interval)
+{
+  t->interval = interval;
+  t->start = clock_time();
+}
+/*---------------------------------------------------------------------------*/
+/**
+ * Reset the timer with the same interval.
+ *
+ * This function resets the timer with the same interval that was
+ * given to the timer_set() function. The start point of the interval
+ * is the exact time that the timer last expired. Therefore, this
+ * function will cause the timer to be stable over time, unlike the
+ * timer_rester() function.
+ *
+ * \param t A pointer to the timer.
+ *
+ * \sa timer_restart()
+ */
+void
+timer_reset(struct timer *t)
+{
+  t->start += t->interval;
+}
+/*---------------------------------------------------------------------------*/
+/**
+ * Restart the timer from the current point in time
+ *
+ * This function restarts a timer with the same interval that was
+ * given to the timer_set() function. The timer will start at the
+ * current time.
+ *
+ * \note A periodic timer will drift if this function is used to reset
+ * it. For preioric timers, use the timer_reset() function instead.
+ *
+ * \param t A pointer to the timer.
+ *
+ * \sa timer_reset()
+ */
+void
+timer_restart(struct timer *t)
+{
+  t->start = clock_time();
+}
+/*---------------------------------------------------------------------------*/
+/**
+ * Check if a timer has expired.
+ *
+ * This function tests if a timer has expired and returns true or
+ * false depending on its status.
+ *
+ * \param t A pointer to the timer
+ *
+ * \return Non-zero if the timer has expired, zero otherwise.
+ *
+ */
+int
+timer_expired(struct timer *t)
+{
+  return (clock_time_t)(clock_time() - t->start) >= (clock_time_t)t->interval;
+}
+/*---------------------------------------------------------------------------*/
+
+/** @} */
diff --git a/Projects/Webserver/Lib/uip/timer.h b/Projects/Webserver/Lib/uip/timer.h
index e28e3ca5f..057bea49c 100644
--- a/Projects/Webserver/Lib/uip/timer.h
+++ b/Projects/Webserver/Lib/uip/timer.h
@@ -1,86 +1,86 @@
-/**

- * \defgroup timer Timer library

- *

- * The timer library provides functions for setting, resetting and

- * restarting timers, and for checking if a timer has expired. An

- * application must "manually" check if its timers have expired; this

- * is not done automatically.

- *

- * A timer is declared as a \c struct \c timer and all access to the

- * timer is made by a pointer to the declared timer.

- *

- * \note The timer library uses the \ref clock "Clock library" to

- * measure time. Intervals should be specified in the format used by

- * the clock library.

- *

- * @{

- */

-

-

-/**

- * \file

- * Timer library header file.

- * \author

- * Adam Dunkels <adam@sics.se>

- */

-

-/*

- * Copyright (c) 2004, Swedish Institute of Computer Science.

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- * 1. Redistributions of source code must retain the above copyright

- *    notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- *    notice, this list of conditions and the following disclaimer in the

- *    documentation and/or other materials provided with the distribution.

- * 3. Neither the name of the Institute nor the names of its contributors

- *    may be used to endorse or promote products derived from this software

- *    without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND

- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

- * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE

- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

- * SUCH DAMAGE.

- *

- * This file is part of the uIP TCP/IP stack

- *

- * Author: Adam Dunkels <adam@sics.se>

- *

- * $Id: timer.h,v 1.3 2006/06/11 21:46:39 adam Exp $

- */

-#ifndef __TIMER_H__

-#define __TIMER_H__

-

-#include "clock.h"

-

-/**

- * A timer.

- *

- * This structure is used for declaring a timer. The timer must be set

- * with timer_set() before it can be used.

- *

- * \hideinitializer

- */

-struct timer {

-  clock_time_t start;

-  clock_time_t interval;

-};

-

-void timer_set(struct timer *t, clock_time_t interval);

-void timer_reset(struct timer *t);

-void timer_restart(struct timer *t);

-int timer_expired(struct timer *t);

-

-#endif /* __TIMER_H__ */

-

-/** @} */

+/**
+ * \defgroup timer Timer library
+ *
+ * The timer library provides functions for setting, resetting and
+ * restarting timers, and for checking if a timer has expired. An
+ * application must "manually" check if its timers have expired; this
+ * is not done automatically.
+ *
+ * A timer is declared as a \c struct \c timer and all access to the
+ * timer is made by a pointer to the declared timer.
+ *
+ * \note The timer library uses the \ref clock "Clock library" to
+ * measure time. Intervals should be specified in the format used by
+ * the clock library.
+ *
+ * @{
+ */
+
+
+/**
+ * \file
+ * Timer library header file.
+ * \author
+ * Adam Dunkels <adam@sics.se>
+ */
+
+/*
+ * Copyright (c) 2004, Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ * $Id: timer.h,v 1.3 2006/06/11 21:46:39 adam Exp $
+ */
+#ifndef __TIMER_H__
+#define __TIMER_H__
+
+#include "clock.h"
+
+/**
+ * A timer.
+ *
+ * This structure is used for declaring a timer. The timer must be set
+ * with timer_set() before it can be used.
+ *
+ * \hideinitializer
+ */
+struct timer {
+  clock_time_t start;
+  clock_time_t interval;
+};
+
+void timer_set(struct timer *t, clock_time_t interval);
+void timer_reset(struct timer *t);
+void timer_restart(struct timer *t);
+int timer_expired(struct timer *t);
+
+#endif /* __TIMER_H__ */
+
+/** @} */
diff --git a/Projects/Webserver/Lib/uip/uip-split.c b/Projects/Webserver/Lib/uip/uip-split.c
index 9b1d1ce88..5924fabe5 100644
--- a/Projects/Webserver/Lib/uip/uip-split.c
+++ b/Projects/Webserver/Lib/uip/uip-split.c
@@ -1,141 +1,141 @@
-/*

- * Copyright (c) 2004, Swedish Institute of Computer Science.

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- * 1. Redistributions of source code must retain the above copyright

- *    notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- *    notice, this list of conditions and the following disclaimer in the

- *    documentation and/or other materials provided with the distribution.

- * 3. Neither the name of the Institute nor the names of its contributors

- *    may be used to endorse or promote products derived from this software

- *    without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND

- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

- * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE

- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

- * SUCH DAMAGE.

- *

- * This file is part of the Contiki operating system.

- *

- * Author: Adam Dunkels <adam@sics.se>

- *

- * $Id: uip-split.c,v 1.2 2008/10/14 13:39:12 julienabeille Exp $

- */

-

-#include "uip-split.h"

-

-

-#define BUF ((struct uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])

-

-/*-----------------------------------------------------------------------------*/

-void

-uip_split_output(void)

-{

-#if UIP_TCP

-  u16_t tcplen, len1, len2;

-

-  /* We only try to split maximum sized TCP segments. */

-  if(BUF->proto == UIP_PROTO_TCP  && uip_len == UIP_BUFSIZE) {

-  

-    tcplen = uip_len - UIP_TCPIP_HLEN - UIP_LLH_LEN;

-    /* Split the segment in two. If the original packet length was

-       odd, we make the second packet one byte larger. */

-    len1 = len2 = tcplen / 2;

-    if(len1 + len2 < tcplen) {

-      ++len2;

-    }

-

-    /* Create the first packet. This is done by altering the length

-       field of the IP header and updating the checksums. */

-    uip_len = len1 + UIP_TCPIP_HLEN + UIP_LLH_LEN;

-#if UIP_CONF_IPV6

-    /* For IPv6, the IP length field does not include the IPv6 IP header

-       length. */

-    BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);

-    BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);

-#else /* UIP_CONF_IPV6 */

-    BUF->len[0] = (uip_len - UIP_LLH_LEN) >> 8;

-    BUF->len[1] = (uip_len - UIP_LLH_LEN) & 0xff;

-#endif /* UIP_CONF_IPV6 */

-    

-    /* Recalculate the TCP checksum. */

-    BUF->tcpchksum = 0;

-    BUF->tcpchksum = ~(uip_tcpchksum());

-

-#if !UIP_CONF_IPV6

-    /* Recalculate the IP checksum. */

-    BUF->ipchksum = 0;

-    BUF->ipchksum = ~(uip_ipchksum());

-#endif /* UIP_CONF_IPV6 */

-    

-    /* Transmit the first packet. */

-#if UIP_CONF_IPV6

-    tcpip_ipv6_output();

-#else

-	RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, uip_buf, uip_len);

-#endif /* UIP_CONF_IPV6 */

-   

-    /* Now, create the second packet. To do this, it is not enough to

-       just alter the length field, but we must also update the TCP

-       sequence number and point the uip_appdata to a new place in

-       memory. This place is detemined by the length of the first

-       packet (len1). */

-    uip_len = len2 + UIP_TCPIP_HLEN + UIP_LLH_LEN;

-#if UIP_CONF_IPV6

-    /* For IPv6, the IP length field does not include the IPv6 IP header

-       length. */

-    BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);

-    BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);

-#else /* UIP_CONF_IPV6 */

-    BUF->len[0] = (uip_len  - UIP_LLH_LEN) >> 8;

-    BUF->len[1] = (uip_len - UIP_LLH_LEN) & 0xff;

-#endif /* UIP_CONF_IPV6 */

-    

-    memcpy(uip_appdata, (u8_t *)uip_appdata + len1, len2);

-

-    uip_add32(BUF->seqno, len1);

-    BUF->seqno[0] = uip_acc32[0];

-    BUF->seqno[1] = uip_acc32[1];

-    BUF->seqno[2] = uip_acc32[2];

-    BUF->seqno[3] = uip_acc32[3];

-    

-    /* Recalculate the TCP checksum. */

-    BUF->tcpchksum = 0;

-    BUF->tcpchksum = ~(uip_tcpchksum());

-

-#if !UIP_CONF_IPV6

-    /* Recalculate the IP checksum. */

-    BUF->ipchksum = 0;

-    BUF->ipchksum = ~(uip_ipchksum());

-#endif /* UIP_CONF_IPV6 */

-

-    /* Transmit the second packet. */

-#if UIP_CONF_IPV6

-    tcpip_ipv6_output();

-#else

-	RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, uip_buf, uip_len);

-#endif /* UIP_CONF_IPV6 */

-    return;

-  }

-#endif /* UIP_TCP */

-

-  /*    uip_fw_output();*/

-#if UIP_CONF_IPV6

-	tcpip_ipv6_output();

-#else

-	RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, uip_buf, uip_len);

-#endif /* UIP_CONF_IPV6 */

-}

-

-/*-----------------------------------------------------------------------------*/

+/*
+ * Copyright (c) 2004, Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the Contiki operating system.
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ * $Id: uip-split.c,v 1.2 2008/10/14 13:39:12 julienabeille Exp $
+ */
+
+#include "uip-split.h"
+
+
+#define BUF ((struct uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])
+
+/*-----------------------------------------------------------------------------*/
+void
+uip_split_output(void)
+{
+#if UIP_TCP
+  u16_t tcplen, len1, len2;
+
+  /* We only try to split maximum sized TCP segments. */
+  if(BUF->proto == UIP_PROTO_TCP  && uip_len == UIP_BUFSIZE) {
+  
+    tcplen = uip_len - UIP_TCPIP_HLEN - UIP_LLH_LEN;
+    /* Split the segment in two. If the original packet length was
+       odd, we make the second packet one byte larger. */
+    len1 = len2 = tcplen / 2;
+    if(len1 + len2 < tcplen) {
+      ++len2;
+    }
+
+    /* Create the first packet. This is done by altering the length
+       field of the IP header and updating the checksums. */
+    uip_len = len1 + UIP_TCPIP_HLEN + UIP_LLH_LEN;
+#if UIP_CONF_IPV6
+    /* For IPv6, the IP length field does not include the IPv6 IP header
+       length. */
+    BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
+    BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
+#else /* UIP_CONF_IPV6 */
+    BUF->len[0] = (uip_len - UIP_LLH_LEN) >> 8;
+    BUF->len[1] = (uip_len - UIP_LLH_LEN) & 0xff;
+#endif /* UIP_CONF_IPV6 */
+    
+    /* Recalculate the TCP checksum. */
+    BUF->tcpchksum = 0;
+    BUF->tcpchksum = ~(uip_tcpchksum());
+
+#if !UIP_CONF_IPV6
+    /* Recalculate the IP checksum. */
+    BUF->ipchksum = 0;
+    BUF->ipchksum = ~(uip_ipchksum());
+#endif /* UIP_CONF_IPV6 */
+    
+    /* Transmit the first packet. */
+#if UIP_CONF_IPV6
+    tcpip_ipv6_output();
+#else
+	RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, uip_buf, uip_len);
+#endif /* UIP_CONF_IPV6 */
+   
+    /* Now, create the second packet. To do this, it is not enough to
+       just alter the length field, but we must also update the TCP
+       sequence number and point the uip_appdata to a new place in
+       memory. This place is detemined by the length of the first
+       packet (len1). */
+    uip_len = len2 + UIP_TCPIP_HLEN + UIP_LLH_LEN;
+#if UIP_CONF_IPV6
+    /* For IPv6, the IP length field does not include the IPv6 IP header
+       length. */
+    BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
+    BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
+#else /* UIP_CONF_IPV6 */
+    BUF->len[0] = (uip_len  - UIP_LLH_LEN) >> 8;
+    BUF->len[1] = (uip_len - UIP_LLH_LEN) & 0xff;
+#endif /* UIP_CONF_IPV6 */
+    
+    memcpy(uip_appdata, (u8_t *)uip_appdata + len1, len2);
+
+    uip_add32(BUF->seqno, len1);
+    BUF->seqno[0] = uip_acc32[0];
+    BUF->seqno[1] = uip_acc32[1];
+    BUF->seqno[2] = uip_acc32[2];
+    BUF->seqno[3] = uip_acc32[3];
+    
+    /* Recalculate the TCP checksum. */
+    BUF->tcpchksum = 0;
+    BUF->tcpchksum = ~(uip_tcpchksum());
+
+#if !UIP_CONF_IPV6
+    /* Recalculate the IP checksum. */
+    BUF->ipchksum = 0;
+    BUF->ipchksum = ~(uip_ipchksum());
+#endif /* UIP_CONF_IPV6 */
+
+    /* Transmit the second packet. */
+#if UIP_CONF_IPV6
+    tcpip_ipv6_output();
+#else
+	RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, uip_buf, uip_len);
+#endif /* UIP_CONF_IPV6 */
+    return;
+  }
+#endif /* UIP_TCP */
+
+  /*    uip_fw_output();*/
+#if UIP_CONF_IPV6
+	tcpip_ipv6_output();
+#else
+	RNDIS_Host_SendPacket(&Ethernet_RNDIS_Interface, uip_buf, uip_len);
+#endif /* UIP_CONF_IPV6 */
+}
+
+/*-----------------------------------------------------------------------------*/
diff --git a/Projects/Webserver/Lib/uip/uip-split.h b/Projects/Webserver/Lib/uip/uip-split.h
index 1df837ef3..c7274c36a 100644
--- a/Projects/Webserver/Lib/uip/uip-split.h
+++ b/Projects/Webserver/Lib/uip/uip-split.h
@@ -1,103 +1,103 @@
-/*

- * Copyright (c) 2004, Swedish Institute of Computer Science.

- * All rights reserved. 

- *

- * Redistribution and use in source and binary forms, with or without 

- * modification, are permitted provided that the following conditions 

- * are met: 

- * 1. Redistributions of source code must retain the above copyright 

- *    notice, this list of conditions and the following disclaimer. 

- * 2. Redistributions in binary form must reproduce the above copyright 

- *    notice, this list of conditions and the following disclaimer in the 

- *    documentation and/or other materials provided with the distribution. 

- * 3. Neither the name of the Institute nor the names of its contributors 

- *    may be used to endorse or promote products derived from this software 

- *    without specific prior written permission. 

- *

- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 

- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 

- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 

- * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 

- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 

- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 

- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 

- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 

- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 

- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 

- * SUCH DAMAGE. 

- *

- * This file is part of the Contiki operating system.

- * 

- * Author: Adam Dunkels <adam@sics.se>

- *

- * $Id: uip-split.h,v 1.1 2006/06/17 22:41:19 adamdunkels Exp $

- */

-/**

- * \addtogroup uip

- * @{

- */

-

-/**

- * \defgroup uipsplit uIP TCP throughput booster hack

- * @{

- *

- * The basic uIP TCP implementation only allows each TCP connection to

- * have a single TCP segment in flight at any given time. Because of

- * the delayed ACK algorithm employed by most TCP receivers, uIP's

- * limit on the amount of in-flight TCP segments seriously reduces the

- * maximum achievable throughput for sending data from uIP.

- *

- * The uip-split module is a hack which tries to remedy this

- * situation. By splitting maximum sized outgoing TCP segments into

- * two, the delayed ACK algorithm is not invoked at TCP

- * receivers. This improves the throughput when sending data from uIP

- * by orders of magnitude.

- *

- * The uip-split module uses the uip-fw module (uIP IP packet

- * forwarding) for sending packets. Therefore, the uip-fw module must

- * be set up with the appropriate network interfaces for this module

- * to work.

- */

-

-

-/**

- * \file

- * Module for splitting outbound TCP segments in two to avoid the

- * delayed ACK throughput degradation. 

- * \author

- * Adam Dunkels <adam@sics.se>

- *

- */

-

-#ifndef __UIP_SPLIT_H__

-#define __UIP_SPLIT_H__

-

-#include <string.h>

-#include <uip.h>

-

-#include "../../USBHostMode.h"

-

-#include <LUFA/Drivers/USB/Class/RNDIS.h>

-

-/**

- * Handle outgoing packets.

- *

- * This function inspects an outgoing packet in the uip_buf buffer and

- * sends it out using the uip_fw_output() function. If the packet is a

- * full-sized TCP segment it will be split into two segments and

- * transmitted separately. This function should be called instead of

- * the actual device driver output function, or the uip_fw_output()

- * function.

- *

- * The headers of the outgoing packet is assumed to be in the uip_buf

- * buffer and the payload is assumed to be wherever uip_appdata

- * points. The length of the outgoing packet is assumed to be in the

- * uip_len variable.

- *

- */

-void uip_split_output(void);

-void uip_add32(u8_t *op32, u16_t op16);

-#endif /* __UIP_SPLIT_H__ */

-

-/** @} */

-/** @} */

+/*
+ * Copyright (c) 2004, Swedish Institute of Computer Science.
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. Redistributions in binary form must reproduce the above copyright 
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution. 
+ * 3. Neither the name of the Institute nor the names of its contributors 
+ *    may be used to endorse or promote products derived from this software 
+ *    without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
+ * SUCH DAMAGE. 
+ *
+ * This file is part of the Contiki operating system.
+ * 
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ * $Id: uip-split.h,v 1.1 2006/06/17 22:41:19 adamdunkels Exp $
+ */
+/**
+ * \addtogroup uip
+ * @{
+ */
+
+/**
+ * \defgroup uipsplit uIP TCP throughput booster hack
+ * @{
+ *
+ * The basic uIP TCP implementation only allows each TCP connection to
+ * have a single TCP segment in flight at any given time. Because of
+ * the delayed ACK algorithm employed by most TCP receivers, uIP's
+ * limit on the amount of in-flight TCP segments seriously reduces the
+ * maximum achievable throughput for sending data from uIP.
+ *
+ * The uip-split module is a hack which tries to remedy this
+ * situation. By splitting maximum sized outgoing TCP segments into
+ * two, the delayed ACK algorithm is not invoked at TCP
+ * receivers. This improves the throughput when sending data from uIP
+ * by orders of magnitude.
+ *
+ * The uip-split module uses the uip-fw module (uIP IP packet
+ * forwarding) for sending packets. Therefore, the uip-fw module must
+ * be set up with the appropriate network interfaces for this module
+ * to work.
+ */
+
+
+/**
+ * \file
+ * Module for splitting outbound TCP segments in two to avoid the
+ * delayed ACK throughput degradation. 
+ * \author
+ * Adam Dunkels <adam@sics.se>
+ *
+ */
+
+#ifndef __UIP_SPLIT_H__
+#define __UIP_SPLIT_H__
+
+#include <string.h>
+#include <uip.h>
+
+#include "../../USBHostMode.h"
+
+#include <LUFA/Drivers/USB/Class/RNDIS.h>
+
+/**
+ * Handle outgoing packets.
+ *
+ * This function inspects an outgoing packet in the uip_buf buffer and
+ * sends it out using the uip_fw_output() function. If the packet is a
+ * full-sized TCP segment it will be split into two segments and
+ * transmitted separately. This function should be called instead of
+ * the actual device driver output function, or the uip_fw_output()
+ * function.
+ *
+ * The headers of the outgoing packet is assumed to be in the uip_buf
+ * buffer and the payload is assumed to be wherever uip_appdata
+ * points. The length of the outgoing packet is assumed to be in the
+ * uip_len variable.
+ *
+ */
+void uip_split_output(void);
+void uip_add32(u8_t *op32, u16_t op16);
+#endif /* __UIP_SPLIT_H__ */
+
+/** @} */
+/** @} */
diff --git a/Projects/Webserver/Lib/uip/uip.c b/Projects/Webserver/Lib/uip/uip.c
index b2c422825..22a72043f 100644
--- a/Projects/Webserver/Lib/uip/uip.c
+++ b/Projects/Webserver/Lib/uip/uip.c
@@ -1,1938 +1,1938 @@
-#define DEBUG_PRINTF(...) /*printf(__VA_ARGS__)*/

-

-/**

- * \addtogroup uip

- * @{

- */

-

-/**

- * \file

- * The uIP TCP/IP stack code.

- * \author Adam Dunkels <adam@dunkels.com>

- */

-

-/*

- * Copyright (c) 2001-2003, Adam Dunkels.

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- * 1. Redistributions of source code must retain the above copyright

- *    notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- *    notice, this list of conditions and the following disclaimer in the

- *    documentation and/or other materials provided with the distribution.

- * 3. The name of the author may not be used to endorse or promote

- *    products derived from this software without specific prior

- *    written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS

- * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE

- * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- *

- * This file is part of the uIP TCP/IP stack.

- *

- * $Id: uip.c,v 1.15 2008/10/15 08:08:32 adamdunkels Exp $

- *

- */

-

-/*

- * uIP is a small implementation of the IP, UDP and TCP protocols (as

- * well as some basic ICMP stuff). The implementation couples the IP,

- * UDP, TCP and the application layers very tightly. To keep the size

- * of the compiled code down, this code frequently uses the goto

- * statement. While it would be possible to break the uip_process()

- * function into many smaller functions, this would increase the code

- * size because of the overhead of parameter passing and the fact that

- * the optimier would not be as efficient.

- *

- * The principle is that we have a small buffer, called the uip_buf,

- * in which the device driver puts an incoming packet. The TCP/IP

- * stack parses the headers in the packet, and calls the

- * application. If the remote host has sent data to the application,

- * this data is present in the uip_buf and the application read the

- * data from there. It is up to the application to put this data into

- * a byte stream if needed. The application will not be fed with data

- * that is out of sequence.

- *

- * If the application whishes to send data to the peer, it should put

- * its data into the uip_buf. The uip_appdata pointer points to the

- * first available byte. The TCP/IP stack will calculate the

- * checksums, and fill in the necessary header fields and finally send

- * the packet back to the peer.

-*/

-

-#include "uip.h"

-#include "uipopt.h"

-#include "uip_arp.h"

-

-#if !UIP_CONF_IPV6 /* If UIP_CONF_IPV6 is defined, we compile the

-		      uip6.c file instead of this one. Therefore

-		      this #ifndef removes the entire compilation

-		      output of the uip.c file */

-

-

-#if UIP_CONF_IPV6

-#include "net/uip-neighbor.h"

-#endif /* UIP_CONF_IPV6 */

-

-#include <string.h>

-

-/*---------------------------------------------------------------------------*/

-/* Variable definitions. */

-

-

-/* The IP address of this host. If it is defined to be fixed (by

-   setting UIP_FIXEDADDR to 1 in uipopt.h), the address is set

-   here. Otherwise, the address */

-#if UIP_FIXEDADDR > 0

-const uip_ipaddr_t uip_hostaddr =

-  { UIP_IPADDR0, UIP_IPADDR1, UIP_IPADDR2, UIP_IPADDR3 };

-const uip_ipaddr_t uip_draddr =

-  { UIP_DRIPADDR0, UIP_DRIPADDR1, UIP_DRIPADDR2, UIP_DRIPADDR3 };

-const uip_ipaddr_t uip_netmask =

-  { UIP_NETMASK0, UIP_NETMASK1, UIP_NETMASK2, UIP_NETMASK3 };

-#else

-uip_ipaddr_t uip_hostaddr, uip_draddr, uip_netmask;

-#endif /* UIP_FIXEDADDR */

-

-const uip_ipaddr_t uip_broadcast_addr =

-#if UIP_CONF_IPV6

-  { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

-      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } };

-#else /* UIP_CONF_IPV6 */

-  { { 0xff, 0xff, 0xff, 0xff } };

-#endif /* UIP_CONF_IPV6 */

-const uip_ipaddr_t uip_all_zeroes_addr = { { 0x0, /* rest is 0 */ } };

-

-#if UIP_FIXEDETHADDR

-const struct uip_eth_addr uip_ethaddr = {{UIP_ETHADDR0,

-					  UIP_ETHADDR1,

-					  UIP_ETHADDR2,

-					  UIP_ETHADDR3,

-					  UIP_ETHADDR4,

-					  UIP_ETHADDR5}};

-#else

-struct uip_eth_addr uip_ethaddr = {{0,0,0,0,0,0}};

-#endif

-

-#ifndef UIP_CONF_EXTERNAL_BUFFER

-u8_t uip_buf[UIP_BUFSIZE + 2];   /* The packet buffer that contains

-				    incoming packets. */

-#endif /* UIP_CONF_EXTERNAL_BUFFER */

-

-void *uip_appdata;               /* The uip_appdata pointer points to

-				    application data. */

-void *uip_sappdata;              /* The uip_appdata pointer points to

-				    the application data which is to

-				    be sent. */

-#if UIP_URGDATA > 0

-void *uip_urgdata;               /* The uip_urgdata pointer points to

-   				    urgent data (out-of-band data), if

-   				    present. */

-u16_t uip_urglen, uip_surglen;

-#endif /* UIP_URGDATA > 0 */

-

-u16_t uip_len, uip_slen;

-                             /* The uip_len is either 8 or 16 bits,

-				depending on the maximum packet

-				size. */

-

-u8_t uip_flags;     /* The uip_flags variable is used for

-				communication between the TCP/IP stack

-				and the application program. */

-struct uip_conn *uip_conn;   /* uip_conn always points to the current

-				connection. */

-

-struct uip_conn uip_conns[UIP_CONNS];

-                             /* The uip_conns array holds all TCP

-				connections. */

-u16_t uip_listenports[UIP_LISTENPORTS];

-                             /* The uip_listenports list all currently

-				listning ports. */

-#if UIP_UDP

-struct uip_udp_conn *uip_udp_conn;

-struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];

-#endif /* UIP_UDP */

-

-static u16_t ipid;           /* Ths ipid variable is an increasing

-				number that is used for the IP ID

-				field. */

-

-void uip_setipid(u16_t id) { ipid = id; }

-

-static u8_t iss[4];          /* The iss variable is used for the TCP

-				initial sequence number. */

-

-#if UIP_ACTIVE_OPEN

-static u16_t lastport;       /* Keeps track of the last port used for

-				a new connection. */

-#endif /* UIP_ACTIVE_OPEN */

-

-/* Temporary variables. */

-u8_t uip_acc32[4];

-static u8_t c, opt;

-static u16_t tmp16;

-

-/* Structures and definitions. */

-#define TCP_FIN 0x01

-#define TCP_SYN 0x02

-#define TCP_RST 0x04

-#define TCP_PSH 0x08

-#define TCP_ACK 0x10

-#define TCP_URG 0x20

-#define TCP_CTL 0x3f

-

-#define TCP_OPT_END     0   /* End of TCP options list */

-#define TCP_OPT_NOOP    1   /* "No-operation" TCP option */

-#define TCP_OPT_MSS     2   /* Maximum segment size TCP option */

-

-#define TCP_OPT_MSS_LEN 4   /* Length of TCP MSS option. */

-

-#define ICMP_ECHO_REPLY 0

-#define ICMP_ECHO       8

-

-#define ICMP_DEST_UNREACHABLE        3

-#define ICMP_PORT_UNREACHABLE        3

-

-#define ICMP6_ECHO_REPLY             129

-#define ICMP6_ECHO                   128

-#define ICMP6_NEIGHBOR_SOLICITATION  135

-#define ICMP6_NEIGHBOR_ADVERTISEMENT 136

-

-#define ICMP6_FLAG_S (1 << 6)

-

-#define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1

-#define ICMP6_OPTION_TARGET_LINK_ADDRESS 2

-

-

-/* Macros. */

-#define BUF ((struct uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])

-#define FBUF ((struct uip_tcpip_hdr *)&uip_reassbuf[0])

-#define ICMPBUF ((struct uip_icmpip_hdr *)&uip_buf[UIP_LLH_LEN])

-#define UDPBUF ((struct uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])

-

-

-#if UIP_STATISTICS == 1

-struct uip_stats uip_stat;

-#define UIP_STAT(s) s

-#else

-#define UIP_STAT(s)

-#endif /* UIP_STATISTICS == 1 */

-

-#if UIP_LOGGING == 1

-#include <stdio.h>

-void uip_log(char *msg);

-#define UIP_LOG(m) uip_log(m)

-#else

-#define UIP_LOG(m)

-#endif /* UIP_LOGGING == 1 */

-

-#if ! UIP_ARCH_ADD32

-void

-uip_add32(u8_t *op32, u16_t op16)

-{

-  uip_acc32[3] = op32[3] + (op16 & 0xff);

-  uip_acc32[2] = op32[2] + (op16 >> 8);

-  uip_acc32[1] = op32[1];

-  uip_acc32[0] = op32[0];

-  

-  if(uip_acc32[2] < (op16 >> 8)) {

-    ++uip_acc32[1];

-    if(uip_acc32[1] == 0) {

-      ++uip_acc32[0];

-    }

-  }

-  

-  

-  if(uip_acc32[3] < (op16 & 0xff)) {

-    ++uip_acc32[2];

-    if(uip_acc32[2] == 0) {

-      ++uip_acc32[1];

-      if(uip_acc32[1] == 0) {

-	++uip_acc32[0];

-      }

-    }

-  }

-}

-

-#endif /* UIP_ARCH_ADD32 */

-

-#if ! UIP_ARCH_CHKSUM

-/*---------------------------------------------------------------------------*/

-static u16_t

-chksum(u16_t sum, const u8_t *data, u16_t len)

-{

-  u16_t t;

-  const u8_t *dataptr;

-  const u8_t *last_byte;

-

-  dataptr = data;

-  last_byte = data + len - 1;

-  

-  while(dataptr < last_byte) {	/* At least two more bytes */

-    t = (dataptr[0] << 8) + dataptr[1];

-    sum += t;

-    if(sum < t) {

-      sum++;		/* carry */

-    }

-    dataptr += 2;

-  }

-  

-  if(dataptr == last_byte) {

-    t = (dataptr[0] << 8) + 0;

-    sum += t;

-    if(sum < t) {

-      sum++;		/* carry */

-    }

-  }

-

-  /* Return sum in host byte order. */

-  return sum;

-}

-/*---------------------------------------------------------------------------*/

-u16_t

-uip_chksum(u16_t *data, u16_t len)

-{

-  return htons(chksum(0, (u8_t *)data, len));

-}

-/*---------------------------------------------------------------------------*/

-#ifndef UIP_ARCH_IPCHKSUM

-u16_t

-uip_ipchksum(void)

-{

-  u16_t sum;

-

-  sum = chksum(0, &uip_buf[UIP_LLH_LEN], UIP_IPH_LEN);

-  DEBUG_PRINTF("uip_ipchksum: sum 0x%04x\n", sum);

-  return (sum == 0) ? 0xffff : htons(sum);

-}

-#endif

-/*---------------------------------------------------------------------------*/

-static u16_t

-upper_layer_chksum(u8_t proto)

-{

-  u16_t upper_layer_len;

-  u16_t sum;

-  

-#if UIP_CONF_IPV6

-  upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]);

-#else /* UIP_CONF_IPV6 */

-  upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]) - UIP_IPH_LEN;

-#endif /* UIP_CONF_IPV6 */

-  

-  /* First sum pseudoheader. */

-  

-  /* IP protocol and length fields. This addition cannot carry. */

-  sum = upper_layer_len + proto;

-  /* Sum IP source and destination addresses. */

-  sum = chksum(sum, (u8_t *)&BUF->srcipaddr, 2 * sizeof(uip_ipaddr_t));

-

-  /* Sum TCP header and data. */

-  sum = chksum(sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN],

-	       upper_layer_len);

-    

-  return (sum == 0) ? 0xffff : htons(sum);

-}

-/*---------------------------------------------------------------------------*/

-#if UIP_CONF_IPV6

-u16_t

-uip_icmp6chksum(void)

-{

-  return upper_layer_chksum(UIP_PROTO_ICMP6);

-  

-}

-#endif /* UIP_CONF_IPV6 */

-/*---------------------------------------------------------------------------*/

-u16_t

-uip_tcpchksum(void)

-{

-  return upper_layer_chksum(UIP_PROTO_TCP);

-}

-/*---------------------------------------------------------------------------*/

-#if UIP_UDP_CHECKSUMS

-u16_t

-uip_udpchksum(void)

-{

-  return upper_layer_chksum(UIP_PROTO_UDP);

-}

-#endif /* UIP_UDP_CHECKSUMS */

-#endif /* UIP_ARCH_CHKSUM */

-/*---------------------------------------------------------------------------*/

-void

-uip_init(void)

-{

-  for(c = 0; c < UIP_LISTENPORTS; ++c) {

-    uip_listenports[c] = 0;

-  }

-  for(c = 0; c < UIP_CONNS; ++c) {

-    uip_conns[c].tcpstateflags = UIP_CLOSED;

-  }

-#if UIP_ACTIVE_OPEN

-  lastport = 1024;

-#endif /* UIP_ACTIVE_OPEN */

-

-#if UIP_UDP

-  for(c = 0; c < UIP_UDP_CONNS; ++c) {

-    uip_udp_conns[c].lport = 0;

-  }

-#endif /* UIP_UDP */

-  

-

-  /* IPv4 initialization. */

-#if UIP_FIXEDADDR == 0

-  /*  uip_hostaddr[0] = uip_hostaddr[1] = 0;*/

-#endif /* UIP_FIXEDADDR */

-

-}

-/*---------------------------------------------------------------------------*/

-#if UIP_ACTIVE_OPEN

-struct uip_conn *

-uip_connect(uip_ipaddr_t *ripaddr, u16_t rport)

-{

-  register struct uip_conn *conn, *cconn;

-  

-  /* Find an unused local port. */

- again:

-  ++lastport;

-

-  if(lastport >= 32000) {

-    lastport = 4096;

-  }

-

-  /* Check if this port is already in use, and if so try to find

-     another one. */

-  for(c = 0; c < UIP_CONNS; ++c) {

-    conn = &uip_conns[c];

-    if(conn->tcpstateflags != UIP_CLOSED &&

-       conn->lport == htons(lastport)) {

-      goto again;

-    }

-  }

-

-  conn = 0;

-  for(c = 0; c < UIP_CONNS; ++c) {

-    cconn = &uip_conns[c];

-    if(cconn->tcpstateflags == UIP_CLOSED) {

-      conn = cconn;

-      break;

-    }

-    if(cconn->tcpstateflags == UIP_TIME_WAIT) {

-      if(conn == 0 ||

-	 cconn->timer > conn->timer) {

-	conn = cconn;

-      }

-    }

-  }

-

-  if(conn == 0) {

-    return 0;

-  }

-  

-  conn->tcpstateflags = UIP_SYN_SENT;

-

-  conn->snd_nxt[0] = iss[0];

-  conn->snd_nxt[1] = iss[1];

-  conn->snd_nxt[2] = iss[2];

-  conn->snd_nxt[3] = iss[3];

-

-  conn->initialmss = conn->mss = UIP_TCP_MSS;

-  

-  conn->len = 1;   /* TCP length of the SYN is one. */

-  conn->nrtx = 0;

-  conn->timer = 1; /* Send the SYN next time around. */

-  conn->rto = UIP_RTO;

-  conn->sa = 0;

-  conn->sv = 16;   /* Initial value of the RTT variance. */

-  conn->lport = htons(lastport);

-  conn->rport = rport;

-  uip_ipaddr_copy(&conn->ripaddr, ripaddr);

-  

-  return conn;

-}

-#endif /* UIP_ACTIVE_OPEN */

-/*---------------------------------------------------------------------------*/

-#if UIP_UDP

-struct uip_udp_conn *

-uip_udp_new(const uip_ipaddr_t *ripaddr, u16_t rport)

-{

-  register struct uip_udp_conn *conn;

-  

-  /* Find an unused local port. */

- again:

-  ++lastport;

-

-  if(lastport >= 32000) {

-    lastport = 4096;

-  }

-  

-  for(c = 0; c < UIP_UDP_CONNS; ++c) {

-    if(uip_udp_conns[c].lport == htons(lastport)) {

-      goto again;

-    }

-  }

-

-

-  conn = 0;

-  for(c = 0; c < UIP_UDP_CONNS; ++c) {

-    if(uip_udp_conns[c].lport == 0) {

-      conn = &uip_udp_conns[c];

-      break;

-    }

-  }

-

-  if(conn == 0) {

-    return 0;

-  }

-  

-  conn->lport = HTONS(lastport);

-  conn->rport = rport;

-  if(ripaddr == NULL) {

-    memset(&conn->ripaddr, 0, sizeof(uip_ipaddr_t));

-  } else {

-    uip_ipaddr_copy(&conn->ripaddr, ripaddr);

-  }

-  conn->ttl = UIP_TTL;

-  

-  return conn;

-}

-#endif /* UIP_UDP */

-/*---------------------------------------------------------------------------*/

-void

-uip_unlisten(u16_t port)

-{

-  for(c = 0; c < UIP_LISTENPORTS; ++c) {

-    if(uip_listenports[c] == port) {

-      uip_listenports[c] = 0;

-      return;

-    }

-  }

-}

-/*---------------------------------------------------------------------------*/

-void

-uip_listen(u16_t port)

-{

-  for(c = 0; c < UIP_LISTENPORTS; ++c) {

-    if(uip_listenports[c] == 0) {

-      uip_listenports[c] = port;

-      return;

-    }

-  }

-}

-/*---------------------------------------------------------------------------*/

-/* XXX: IP fragment reassembly: not well-tested. */

-

-#if UIP_REASSEMBLY && !UIP_CONF_IPV6

-#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)

-static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];

-static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];

-static const u8_t bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f,

-				    0x0f, 0x07, 0x03, 0x01};

-static u16_t uip_reasslen;

-static u8_t uip_reassflags;

-#define UIP_REASS_FLAG_LASTFRAG 0x01

-static u8_t uip_reasstmr;

-

-#define IP_MF   0x20

-

-static u8_t

-uip_reass(void)

-{

-  u16_t offset, len;

-  u16_t i;

-

-  /* If ip_reasstmr is zero, no packet is present in the buffer, so we

-     write the IP header of the fragment into the reassembly

-     buffer. The timer is updated with the maximum age. */

-  if(uip_reasstmr == 0) {

-    memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN);

-    uip_reasstmr = UIP_REASS_MAXAGE;

-    uip_reassflags = 0;

-    /* Clear the bitmap. */

-    memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap));

-  }

-

-  /* Check if the incoming fragment matches the one currently present

-     in the reasembly buffer. If so, we proceed with copying the

-     fragment into the buffer. */

-  if(BUF->srcipaddr[0] == FBUF->srcipaddr[0] &&

-     BUF->srcipaddr[1] == FBUF->srcipaddr[1] &&

-     BUF->destipaddr[0] == FBUF->destipaddr[0] &&

-     BUF->destipaddr[1] == FBUF->destipaddr[1] &&

-     BUF->ipid[0] == FBUF->ipid[0] &&

-     BUF->ipid[1] == FBUF->ipid[1]) {

-

-    len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;

-    offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;

-

-    /* If the offset or the offset + fragment length overflows the

-       reassembly buffer, we discard the entire packet. */

-    if(offset > UIP_REASS_BUFSIZE ||

-       offset + len > UIP_REASS_BUFSIZE) {

-      uip_reasstmr = 0;

-      goto nullreturn;

-    }

-

-    /* Copy the fragment into the reassembly buffer, at the right

-       offset. */

-    memcpy(&uip_reassbuf[UIP_IPH_LEN + offset],

-	   (char *)BUF + (int)((BUF->vhl & 0x0f) * 4),

-	   len);

-      

-    /* Update the bitmap. */

-    if(offset / (8 * 8) == (offset + len) / (8 * 8)) {

-      /* If the two endpoints are in the same byte, we only update

-	 that byte. */

-	     

-      uip_reassbitmap[offset / (8 * 8)] |=

-	     bitmap_bits[(offset / 8 ) & 7] &

-	     ~bitmap_bits[((offset + len) / 8 ) & 7];

-    } else {

-      /* If the two endpoints are in different bytes, we update the

-	 bytes in the endpoints and fill the stuff inbetween with

-	 0xff. */

-      uip_reassbitmap[offset / (8 * 8)] |=

-	bitmap_bits[(offset / 8 ) & 7];

-      for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {

-	uip_reassbitmap[i] = 0xff;

-      }

-      uip_reassbitmap[(offset + len) / (8 * 8)] |=

-	~bitmap_bits[((offset + len) / 8 ) & 7];

-    }

-    

-    /* If this fragment has the More Fragments flag set to zero, we

-       know that this is the last fragment, so we can calculate the

-       size of the entire packet. We also set the

-       IP_REASS_FLAG_LASTFRAG flag to indicate that we have received

-       the final fragment. */

-

-    if((BUF->ipoffset[0] & IP_MF) == 0) {

-      uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;

-      uip_reasslen = offset + len;

-    }

-    

-    /* Finally, we check if we have a full packet in the buffer. We do

-       this by checking if we have the last fragment and if all bits

-       in the bitmap are set. */

-    if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {

-      /* Check all bytes up to and including all but the last byte in

-	 the bitmap. */

-      for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {

-	if(uip_reassbitmap[i] != 0xff) {

-	  goto nullreturn;

-	}

-      }

-      /* Check the last byte in the bitmap. It should contain just the

-	 right amount of bits. */

-      if(uip_reassbitmap[uip_reasslen / (8 * 8)] !=

-	 (u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {

-	goto nullreturn;

-      }

-

-      /* If we have come this far, we have a full packet in the

-	 buffer, so we allocate a pbuf and copy the packet into it. We

-	 also reset the timer. */

-      uip_reasstmr = 0;

-      memcpy(BUF, FBUF, uip_reasslen);

-

-      /* Pretend to be a "normal" (i.e., not fragmented) IP packet

-	 from now on. */

-      BUF->ipoffset[0] = BUF->ipoffset[1] = 0;

-      BUF->len[0] = uip_reasslen >> 8;

-      BUF->len[1] = uip_reasslen & 0xff;

-      BUF->ipchksum = 0;

-      BUF->ipchksum = ~(uip_ipchksum());

-

-      return uip_reasslen;

-    }

-  }

-

- nullreturn:

-  return 0;

-}

-#endif /* UIP_REASSEMBLY */

-/*---------------------------------------------------------------------------*/

-static void

-uip_add_rcv_nxt(u16_t n)

-{

-  uip_add32(uip_conn->rcv_nxt, n);

-  uip_conn->rcv_nxt[0] = uip_acc32[0];

-  uip_conn->rcv_nxt[1] = uip_acc32[1];

-  uip_conn->rcv_nxt[2] = uip_acc32[2];

-  uip_conn->rcv_nxt[3] = uip_acc32[3];

-}

-/*---------------------------------------------------------------------------*/

-void

-uip_process(u8_t flag)

-{

-  register struct uip_conn *uip_connr = uip_conn;

-

-#if UIP_UDP

-  if(flag == UIP_UDP_SEND_CONN) {

-    goto udp_send;

-  }

-#endif /* UIP_UDP */

-  

-  uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];

-

-  /* Check if we were invoked because of a poll request for a

-     particular connection. */

-  if(flag == UIP_POLL_REQUEST) {

-    if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED &&

-       !uip_outstanding(uip_connr)) {

-	uip_len = uip_slen = 0;

-	uip_flags = UIP_POLL;

-	UIP_APPCALL();

-	goto appsend;

-    }

-    goto drop;

-    

-    /* Check if we were invoked because of the perodic timer fireing. */

-  } else if(flag == UIP_TIMER) {

-#if UIP_REASSEMBLY

-    if(uip_reasstmr != 0) {

-      --uip_reasstmr;

-    }

-#endif /* UIP_REASSEMBLY */

-    /* Increase the initial sequence number. */

-    if(++iss[3] == 0) {

-      if(++iss[2] == 0) {

-	if(++iss[1] == 0) {

-	  ++iss[0];

-	}

-      }

-    }

-

-    /* Reset the length variables. */

-    uip_len = 0;

-    uip_slen = 0;

-

-    /* Check if the connection is in a state in which we simply wait

-       for the connection to time out. If so, we increase the

-       connection's timer and remove the connection if it times

-       out. */

-    if(uip_connr->tcpstateflags == UIP_TIME_WAIT ||

-       uip_connr->tcpstateflags == UIP_FIN_WAIT_2) {

-      ++(uip_connr->timer);

-      if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {

-	uip_connr->tcpstateflags = UIP_CLOSED;

-      }

-    } else if(uip_connr->tcpstateflags != UIP_CLOSED) {

-      /* If the connection has outstanding data, we increase the

-	 connection's timer and see if it has reached the RTO value

-	 in which case we retransmit. */

-      if(uip_outstanding(uip_connr)) {

-	if(uip_connr->timer-- == 0) {

-	  if(uip_connr->nrtx == UIP_MAXRTX ||

-	     ((uip_connr->tcpstateflags == UIP_SYN_SENT ||

-	       uip_connr->tcpstateflags == UIP_SYN_RCVD) &&

-	      uip_connr->nrtx == UIP_MAXSYNRTX)) {

-	    uip_connr->tcpstateflags = UIP_CLOSED;

-

-	    /* We call UIP_APPCALL() with uip_flags set to

-	       UIP_TIMEDOUT to inform the application that the

-	       connection has timed out. */

-	    uip_flags = UIP_TIMEDOUT;

-	    UIP_APPCALL();

-

-	    /* We also send a reset packet to the remote host. */

-	    BUF->flags = TCP_RST | TCP_ACK;

-	    goto tcp_send_nodata;

-	  }

-

-	  /* Exponential backoff. */

-	  uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4?

-					 4:

-					 uip_connr->nrtx);

-	  ++(uip_connr->nrtx);

-	  

-	  /* Ok, so we need to retransmit. We do this differently

-	     depending on which state we are in. In ESTABLISHED, we

-	     call upon the application so that it may prepare the

-	     data for the retransmit. In SYN_RCVD, we resend the

-	     SYNACK that we sent earlier and in LAST_ACK we have to

-	     retransmit our FINACK. */

-	  UIP_STAT(++uip_stat.tcp.rexmit);

-	  switch(uip_connr->tcpstateflags & UIP_TS_MASK) {

-	  case UIP_SYN_RCVD:

-	    /* In the SYN_RCVD state, we should retransmit our

-               SYNACK. */

-	    goto tcp_send_synack;

-	    

-#if UIP_ACTIVE_OPEN

-	  case UIP_SYN_SENT:

-	    /* In the SYN_SENT state, we retransmit out SYN. */

-	    BUF->flags = 0;

-	    goto tcp_send_syn;

-#endif /* UIP_ACTIVE_OPEN */

-	    

-	  case UIP_ESTABLISHED:

-	    /* In the ESTABLISHED state, we call upon the application

-               to do the actual retransmit after which we jump into

-               the code for sending out the packet (the apprexmit

-               label). */

-	    uip_flags = UIP_REXMIT;

-	    UIP_APPCALL();

-	    goto apprexmit;

-	    

-	  case UIP_FIN_WAIT_1:

-	  case UIP_CLOSING:

-	  case UIP_LAST_ACK:

-	    /* In all these states we should retransmit a FINACK. */

-	    goto tcp_send_finack;

-	    

-	  }

-	}

-      } else if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED) {

-	/* If there was no need for a retransmission, we poll the

-           application for new data. */

-	uip_len = uip_slen = 0;		   

-	uip_flags = UIP_POLL;

-	UIP_APPCALL();

-	goto appsend;

-      }

-    }

-    goto drop;

-  }

-#if UIP_UDP

-  if(flag == UIP_UDP_TIMER) {

-    if(uip_udp_conn->lport != 0) {

-      uip_conn = NULL;

-      uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];

-      uip_len = uip_slen = 0;

-      uip_flags = UIP_POLL;

-      UIP_UDP_APPCALL();

-      goto udp_send;

-    } else {

-      goto drop;

-    }

-  }

-#endif

-

-  /* This is where the input processing starts. */

-  UIP_STAT(++uip_stat.ip.recv);

-

-  /* Start of IP input header processing code. */

-  

-#if UIP_CONF_IPV6

-  /* Check validity of the IP header. */

-  if((BUF->vtc & 0xf0) != 0x60)  { /* IP version and header length. */

-    UIP_STAT(++uip_stat.ip.drop);

-    UIP_STAT(++uip_stat.ip.vhlerr);

-    UIP_LOG("ipv6: invalid version.");

-    goto drop;

-  }

-#else /* UIP_CONF_IPV6 */

-  /* Check validity of the IP header. */

-  if(BUF->vhl != 0x45)  { /* IP version and header length. */

-    UIP_STAT(++uip_stat.ip.drop);

-    UIP_STAT(++uip_stat.ip.vhlerr);

-    UIP_LOG("ip: invalid version or header length.");

-    goto drop;

-  }

-#endif /* UIP_CONF_IPV6 */

-  

-  /* Check the size of the packet. If the size reported to us in

-     uip_len is smaller the size reported in the IP header, we assume

-     that the packet has been corrupted in transit. If the size of

-     uip_len is larger than the size reported in the IP packet header,

-     the packet has been padded and we set uip_len to the correct

-     value.. */

-

-  if((BUF->len[0] << 8) + BUF->len[1] <= uip_len) {

-    uip_len = (BUF->len[0] << 8) + BUF->len[1];

-#if UIP_CONF_IPV6

-    uip_len += 40; /* The length reported in the IPv6 header is the

-		      length of the payload that follows the

-		      header. However, uIP uses the uip_len variable

-		      for holding the size of the entire packet,

-		      including the IP header. For IPv4 this is not a

-		      problem as the length field in the IPv4 header

-		      contains the length of the entire packet. But

-		      for IPv6 we need to add the size of the IPv6

-		      header (40 bytes). */

-#endif /* UIP_CONF_IPV6 */

-  } else {

-    UIP_LOG("ip: packet shorter than reported in IP header.");

-    goto drop;

-  }

-

-#if !UIP_CONF_IPV6

-  /* Check the fragment flag. */

-  if((BUF->ipoffset[0] & 0x3f) != 0 ||

-     BUF->ipoffset[1] != 0) {

-#if UIP_REASSEMBLY

-    uip_len = uip_reass();

-    if(uip_len == 0) {

-      goto drop;

-    }

-#else /* UIP_REASSEMBLY */

-    UIP_STAT(++uip_stat.ip.drop);

-    UIP_STAT(++uip_stat.ip.fragerr);

-    UIP_LOG("ip: fragment dropped.");

-    goto drop;

-#endif /* UIP_REASSEMBLY */

-  }

-#endif /* UIP_CONF_IPV6 */

-

-  if(uip_ipaddr_cmp(&uip_hostaddr, &uip_all_zeroes_addr)) {

-    /* If we are configured to use ping IP address configuration and

-       hasn't been assigned an IP address yet, we accept all ICMP

-       packets. */

-#if UIP_PINGADDRCONF && !UIP_CONF_IPV6

-    if(BUF->proto == UIP_PROTO_ICMP) {

-      UIP_LOG("ip: possible ping config packet received.");

-      goto icmp_input;

-    } else {

-      UIP_LOG("ip: packet dropped since no address assigned.");

-      goto drop;

-    }

-#endif /* UIP_PINGADDRCONF */

-

-  } else {

-    /* If IP broadcast support is configured, we check for a broadcast

-       UDP packet, which may be destined to us. */

-#if UIP_BROADCAST

-    DEBUG_PRINTF("UDP IP checksum 0x%04x\n", uip_ipchksum());

-    if(BUF->proto == UIP_PROTO_UDP &&

-       uip_ipaddr_cmp(&BUF->destipaddr, &uip_broadcast_addr)

-       /*&&

-	 uip_ipchksum() == 0xffff*/) {

-      goto udp_input;

-    }

-#endif /* UIP_BROADCAST */

-    

-    /* Check if the packet is destined for our IP address. */

-#if !UIP_CONF_IPV6

-    if(!uip_ipaddr_cmp(&BUF->destipaddr, &uip_hostaddr)) {

-      UIP_STAT(++uip_stat.ip.drop);

-      goto drop;

-    }

-#else /* UIP_CONF_IPV6 */

-    /* For IPv6, packet reception is a little trickier as we need to

-       make sure that we listen to certain multicast addresses (all

-       hosts multicast address, and the solicited-node multicast

-       address) as well. However, we will cheat here and accept all

-       multicast packets that are sent to the ff02::/16 addresses. */

-    if(!uip_ipaddr_cmp(&BUF->destipaddr, &uip_hostaddr) &&

-       BUF->destipaddr.u16[0] != HTONS(0xff02)) {

-      UIP_STAT(++uip_stat.ip.drop);

-      goto drop;

-    }

-#endif /* UIP_CONF_IPV6 */

-  }

-

-#if !UIP_CONF_IPV6

-  if(uip_ipchksum() != 0xffff) { /* Compute and check the IP header

-				    checksum. */

-    UIP_STAT(++uip_stat.ip.drop);

-    UIP_STAT(++uip_stat.ip.chkerr);

-    UIP_LOG("ip: bad checksum.");

-    goto drop;

-  }

-#endif /* UIP_CONF_IPV6 */

-

-  if(BUF->proto == UIP_PROTO_TCP) { /* Check for TCP packet. If so,

-				       proceed with TCP input

-				       processing. */

-    goto tcp_input;

-  }

-

-#if UIP_UDP

-  if(BUF->proto == UIP_PROTO_UDP) {

-    goto udp_input;

-  }

-#endif /* UIP_UDP */

-

-#if !UIP_CONF_IPV6

-  /* ICMPv4 processing code follows. */

-  if(BUF->proto != UIP_PROTO_ICMP) { /* We only allow ICMP packets from

-					here. */

-    UIP_STAT(++uip_stat.ip.drop);

-    UIP_STAT(++uip_stat.ip.protoerr);

-    UIP_LOG("ip: neither tcp nor icmp.");

-    goto drop;

-  }

-

-#if UIP_PINGADDRCONF

- icmp_input:

-#endif /* UIP_PINGADDRCONF */

-  UIP_STAT(++uip_stat.icmp.recv);

-

-  /* ICMP echo (i.e., ping) processing. This is simple, we only change

-     the ICMP type from ECHO to ECHO_REPLY and adjust the ICMP

-     checksum before we return the packet. */

-  if(ICMPBUF->type != ICMP_ECHO) {

-    UIP_STAT(++uip_stat.icmp.drop);

-    UIP_STAT(++uip_stat.icmp.typeerr);

-    UIP_LOG("icmp: not icmp echo.");

-    goto drop;

-  }

-

-  /* If we are configured to use ping IP address assignment, we use

-     the destination IP address of this ping packet and assign it to

-     ourself. */

-#if UIP_PINGADDRCONF

-  if(uip_ipaddr_cmp(&uip_hostaddr, &uip_all_zeroes_addr)) {

-    uip_hostaddr = BUF->destipaddr;

-  }

-#endif /* UIP_PINGADDRCONF */

-

-  ICMPBUF->type = ICMP_ECHO_REPLY;

-

-  if(ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) {

-    ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;

-  } else {

-    ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);

-  }

-

-  /* Swap IP addresses. */

-  uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);

-  uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);

-

-  UIP_STAT(++uip_stat.icmp.sent);

-  BUF->ttl = UIP_TTL;

-  goto ip_send_nolen;

-

-  /* End of IPv4 input header processing code. */

-#else /* !UIP_CONF_IPV6 */

-

-  /* This is IPv6 ICMPv6 processing code. */

-  DEBUG_PRINTF("icmp6_input: length %d\n", uip_len);

-

-  if(BUF->proto != UIP_PROTO_ICMP6) { /* We only allow ICMPv6 packets from

-					 here. */

-    UIP_STAT(++uip_stat.ip.drop);

-    UIP_STAT(++uip_stat.ip.protoerr);

-    UIP_LOG("ip: neither tcp nor icmp6.");

-    goto drop;

-  }

-

-  UIP_STAT(++uip_stat.icmp.recv);

-

-  /* If we get a neighbor solicitation for our address we should send

-     a neighbor advertisement message back. */

-  if(ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION) {

-    if(uip_ipaddr_cmp(&ICMPBUF->icmp6data, &uip_hostaddr)) {

-

-      if(ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS) {

-	/* Save the sender's address in our neighbor list. */

-	uip_neighbor_add(&ICMPBUF->srcipaddr, &(ICMPBUF->options[2]));

-      }

-      

-      /* We should now send a neighbor advertisement back to where the

-	 neighbor solicication came from. */

-      ICMPBUF->type = ICMP6_NEIGHBOR_ADVERTISEMENT;

-      ICMPBUF->flags = ICMP6_FLAG_S; /* Solicited flag. */

-      

-      ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0;

-      

-      uip_ipaddr_copy(&ICMPBUF->destipaddr, &ICMPBUF->srcipaddr);

-      uip_ipaddr_copy(&ICMPBUF->srcipaddr, &uip_hostaddr);

-      ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;

-      ICMPBUF->options[1] = 1;  /* Options length, 1 = 8 bytes. */

-      memcpy(&(ICMPBUF->options[2]), &uip_ethaddr, sizeof(uip_ethaddr));

-      ICMPBUF->icmpchksum = 0;

-      ICMPBUF->icmpchksum = ~uip_icmp6chksum();

-      

-      goto send;

-      

-    }

-    goto drop;

-  } else if(ICMPBUF->type == ICMP6_ECHO) {

-    /* ICMP echo (i.e., ping) processing. This is simple, we only

-       change the ICMP type from ECHO to ECHO_REPLY and update the

-       ICMP checksum before we return the packet. */

-

-    ICMPBUF->type = ICMP6_ECHO_REPLY;

-    

-    uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);

-    uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);

-    ICMPBUF->icmpchksum = 0;

-    ICMPBUF->icmpchksum = ~uip_icmp6chksum();

-    

-    UIP_STAT(++uip_stat.icmp.sent);

-    goto send;

-  } else {

-    DEBUG_PRINTF("Unknown icmp6 message type %d\n", ICMPBUF->type);

-    UIP_STAT(++uip_stat.icmp.drop);

-    UIP_STAT(++uip_stat.icmp.typeerr);

-    UIP_LOG("icmp: unknown ICMP message.");

-    goto drop;

-  }

-

-  /* End of IPv6 ICMP processing. */

-  

-#endif /* !UIP_CONF_IPV6 */

-

-#if UIP_UDP

-  /* UDP input processing. */

- udp_input:

-  /* UDP processing is really just a hack. We don't do anything to the

-     UDP/IP headers, but let the UDP application do all the hard

-     work. If the application sets uip_slen, it has a packet to

-     send. */

-#if UIP_UDP_CHECKSUMS

-  uip_len = uip_len - UIP_IPUDPH_LEN;

-  uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];

-  if(UDPBUF->udpchksum != 0 && uip_udpchksum() != 0xffff) {

-    UIP_STAT(++uip_stat.udp.drop);

-    UIP_STAT(++uip_stat.udp.chkerr);

-    UIP_LOG("udp: bad checksum.");

-    goto drop;

-  }

-#else /* UIP_UDP_CHECKSUMS */

-  uip_len = uip_len - UIP_IPUDPH_LEN;

-#endif /* UIP_UDP_CHECKSUMS */

-

-  /* Demultiplex this UDP packet between the UDP "connections". */

-  for(uip_udp_conn = &uip_udp_conns[0];

-      uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS];

-      ++uip_udp_conn) {

-    /* If the local UDP port is non-zero, the connection is considered

-       to be used. If so, the local port number is checked against the

-       destination port number in the received packet. If the two port

-       numbers match, the remote port number is checked if the

-       connection is bound to a remote port. Finally, if the

-       connection is bound to a remote IP address, the source IP

-       address of the packet is checked. */

-    if(uip_udp_conn->lport != 0 &&

-       UDPBUF->destport == uip_udp_conn->lport &&

-       (uip_udp_conn->rport == 0 ||

-        UDPBUF->srcport == uip_udp_conn->rport) &&

-       (uip_ipaddr_cmp(&uip_udp_conn->ripaddr, &uip_all_zeroes_addr) ||

-	uip_ipaddr_cmp(&uip_udp_conn->ripaddr, &uip_broadcast_addr) ||

-	uip_ipaddr_cmp(&BUF->srcipaddr, &uip_udp_conn->ripaddr))) {

-      goto udp_found;

-    }

-  }

-  UIP_LOG("udp: no matching connection found");

-#if UIP_CONF_ICMP_DEST_UNREACH && !UIP_CONF_IPV6

-  /* Copy fields from packet header into payload of this ICMP packet. */

-  memcpy(&(ICMPBUF->payload[0]), ICMPBUF, UIP_IPH_LEN + 8);

-

-  /* Set the ICMP type and code. */

-  ICMPBUF->type = ICMP_DEST_UNREACHABLE;

-  ICMPBUF->icode = ICMP_PORT_UNREACHABLE;

-

-  /* Calculate the ICMP checksum. */

-  ICMPBUF->icmpchksum = 0;

-  ICMPBUF->icmpchksum = ~uip_chksum((u16_t *)&(ICMPBUF->type), 36);

-

-  /* Set the IP destination address to be the source address of the

-     original packet. */

-  uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);

-

-  /* Set our IP address as the source address. */

-  uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);

-

-  /* The size of the ICMP destination unreachable packet is 36 + the

-     size of the IP header (20) = 56. */

-  uip_len = 36 + UIP_IPH_LEN;

-  ICMPBUF->len[0] = 0;

-  ICMPBUF->len[1] = (u8_t)uip_len;

-  ICMPBUF->ttl = UIP_TTL;

-  ICMPBUF->proto = UIP_PROTO_ICMP;

-

-  goto ip_send_nolen;

-#else /* UIP_CONF_ICMP_DEST_UNREACH */

-  goto drop;

-#endif /* UIP_CONF_ICMP_DEST_UNREACH */

-  

- udp_found:

-  uip_conn = NULL;

-  uip_flags = UIP_NEWDATA;

-  uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];

-  uip_slen = 0;

-  UIP_UDP_APPCALL();

-

- udp_send:

-  if(uip_slen == 0) {

-    goto drop;

-  }

-  uip_len = uip_slen + UIP_IPUDPH_LEN;

-

-#if UIP_CONF_IPV6

-  /* For IPv6, the IP length field does not include the IPv6 IP header

-     length. */

-  BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);

-  BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);

-#else /* UIP_CONF_IPV6 */

-  BUF->len[0] = (uip_len >> 8);

-  BUF->len[1] = (uip_len & 0xff);

-#endif /* UIP_CONF_IPV6 */

-

-  BUF->ttl = uip_udp_conn->ttl;

-  BUF->proto = UIP_PROTO_UDP;

-

-  UDPBUF->udplen = HTONS(uip_slen + UIP_UDPH_LEN);

-  UDPBUF->udpchksum = 0;

-

-  BUF->srcport  = uip_udp_conn->lport;

-  BUF->destport = uip_udp_conn->rport;

-

-  uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);

-  uip_ipaddr_copy(&BUF->destipaddr, &uip_udp_conn->ripaddr);

-   

-  uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPTCPH_LEN];

-

-#if UIP_UDP_CHECKSUMS

-  /* Calculate UDP checksum. */

-  UDPBUF->udpchksum = ~(uip_udpchksum());

-  if(UDPBUF->udpchksum == 0) {

-    UDPBUF->udpchksum = 0xffff;

-  }

-#endif /* UIP_UDP_CHECKSUMS */

-  

-  goto ip_send_nolen;

-#endif /* UIP_UDP */

-  

-  /* TCP input processing. */

- tcp_input:

-  UIP_STAT(++uip_stat.tcp.recv);

-

-  /* Start of TCP input header processing code. */

-  

-  if(uip_tcpchksum() != 0xffff) {   /* Compute and check the TCP

-				       checksum. */

-    UIP_STAT(++uip_stat.tcp.drop);

-    UIP_STAT(++uip_stat.tcp.chkerr);

-    UIP_LOG("tcp: bad checksum.");

-    goto drop;

-  }

-  

-  /* Demultiplex this segment. */

-  /* First check any active connections. */

-  for(uip_connr = &uip_conns[0]; uip_connr <= &uip_conns[UIP_CONNS - 1];

-      ++uip_connr) {

-    if(uip_connr->tcpstateflags != UIP_CLOSED &&

-       BUF->destport == uip_connr->lport &&

-       BUF->srcport == uip_connr->rport &&

-       uip_ipaddr_cmp(&BUF->srcipaddr, &uip_connr->ripaddr)) {

-      goto found;

-    }

-  }

-

-  /* If we didn't find and active connection that expected the packet,

-     either this packet is an old duplicate, or this is a SYN packet

-     destined for a connection in LISTEN. If the SYN flag isn't set,

-     it is an old packet and we send a RST. */

-  if((BUF->flags & TCP_CTL) != TCP_SYN) {

-    goto reset;

-  }

-  

-  tmp16 = BUF->destport;

-  /* Next, check listening connections. */

-  for(c = 0; c < UIP_LISTENPORTS; ++c) {

-    if(tmp16 == uip_listenports[c]) {

-      goto found_listen;

-    }

-  }

-  

-  /* No matching connection found, so we send a RST packet. */

-  UIP_STAT(++uip_stat.tcp.synrst);

-

- reset:

-  /* We do not send resets in response to resets. */

-  if(BUF->flags & TCP_RST) {

-    goto drop;

-  }

-

-  UIP_STAT(++uip_stat.tcp.rst);

-  

-  BUF->flags = TCP_RST | TCP_ACK;

-  uip_len = UIP_IPTCPH_LEN;

-  BUF->tcpoffset = 5 << 4;

-

-  /* Flip the seqno and ackno fields in the TCP header. */

-  c = BUF->seqno[3];

-  BUF->seqno[3] = BUF->ackno[3];

-  BUF->ackno[3] = c;

-  

-  c = BUF->seqno[2];

-  BUF->seqno[2] = BUF->ackno[2];

-  BUF->ackno[2] = c;

-  

-  c = BUF->seqno[1];

-  BUF->seqno[1] = BUF->ackno[1];

-  BUF->ackno[1] = c;

-  

-  c = BUF->seqno[0];

-  BUF->seqno[0] = BUF->ackno[0];

-  BUF->ackno[0] = c;

-

-  /* We also have to increase the sequence number we are

-     acknowledging. If the least significant byte overflowed, we need

-     to propagate the carry to the other bytes as well. */

-  if(++BUF->ackno[3] == 0) {

-    if(++BUF->ackno[2] == 0) {

-      if(++BUF->ackno[1] == 0) {

-	++BUF->ackno[0];

-      }

-    }

-  }

- 

-  /* Swap port numbers. */

-  tmp16 = BUF->srcport;

-  BUF->srcport = BUF->destport;

-  BUF->destport = tmp16;

-  

-  /* Swap IP addresses. */

-  uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);

-  uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);

-  

-  /* And send out the RST packet! */

-  goto tcp_send_noconn;

-

-  /* This label will be jumped to if we matched the incoming packet

-     with a connection in LISTEN. In that case, we should create a new

-     connection and send a SYNACK in return. */

- found_listen:

-  /* First we check if there are any connections avaliable. Unused

-     connections are kept in the same table as used connections, but

-     unused ones have the tcpstate set to CLOSED. Also, connections in

-     TIME_WAIT are kept track of and we'll use the oldest one if no

-     CLOSED connections are found. Thanks to Eddie C. Dost for a very

-     nice algorithm for the TIME_WAIT search. */

-  uip_connr = 0;

-  for(c = 0; c < UIP_CONNS; ++c) {

-    if(uip_conns[c].tcpstateflags == UIP_CLOSED) {

-      uip_connr = &uip_conns[c];

-      break;

-    }

-    if(uip_conns[c].tcpstateflags == UIP_TIME_WAIT) {

-      if(uip_connr == 0 ||

-	 uip_conns[c].timer > uip_connr->timer) {

-	uip_connr = &uip_conns[c];

-      }

-    }

-  }

-

-  if(uip_connr == 0) {

-    /* All connections are used already, we drop packet and hope that

-       the remote end will retransmit the packet at a time when we

-       have more spare connections. */

-    UIP_STAT(++uip_stat.tcp.syndrop);

-    UIP_LOG("tcp: found no unused connections.");

-    goto drop;

-  }

-  uip_conn = uip_connr;

-  

-  /* Fill in the necessary fields for the new connection. */

-  uip_connr->rto = uip_connr->timer = UIP_RTO;

-  uip_connr->sa = 0;

-  uip_connr->sv = 4;

-  uip_connr->nrtx = 0;

-  uip_connr->lport = BUF->destport;

-  uip_connr->rport = BUF->srcport;

-  uip_ipaddr_copy(&uip_connr->ripaddr, &BUF->srcipaddr);

-  uip_connr->tcpstateflags = UIP_SYN_RCVD;

-

-  uip_connr->snd_nxt[0] = iss[0];

-  uip_connr->snd_nxt[1] = iss[1];

-  uip_connr->snd_nxt[2] = iss[2];

-  uip_connr->snd_nxt[3] = iss[3];

-  uip_connr->len = 1;

-

-  /* rcv_nxt should be the seqno from the incoming packet + 1. */

-  uip_connr->rcv_nxt[3] = BUF->seqno[3];

-  uip_connr->rcv_nxt[2] = BUF->seqno[2];

-  uip_connr->rcv_nxt[1] = BUF->seqno[1];

-  uip_connr->rcv_nxt[0] = BUF->seqno[0];

-  uip_add_rcv_nxt(1);

-

-  /* Parse the TCP MSS option, if present. */

-  if((BUF->tcpoffset & 0xf0) > 0x50) {

-    for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {

-      opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];

-      if(opt == TCP_OPT_END) {

-	/* End of options. */

-	break;

-      } else if(opt == TCP_OPT_NOOP) {

-	++c;

-	/* NOP option. */

-      } else if(opt == TCP_OPT_MSS &&

-		uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {

-	/* An MSS option with the right option length. */

-	tmp16 = ((u16_t)uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |

-	  (u16_t)uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + c];

-	uip_connr->initialmss = uip_connr->mss =

-	  tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;

-	

-	/* And we are done processing options. */

-	break;

-      } else {

-	/* All other options have a length field, so that we easily

-	   can skip past them. */

-	if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {

-	  /* If the length field is zero, the options are malformed

-	     and we don't process them further. */

-	  break;

-	}

-	c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];

-      }

-    }

-  }

-  

-  /* Our response will be a SYNACK. */

-#if UIP_ACTIVE_OPEN

- tcp_send_synack:

-  BUF->flags = TCP_ACK;

-  

- tcp_send_syn:

-  BUF->flags |= TCP_SYN;

-#else /* UIP_ACTIVE_OPEN */

- tcp_send_synack:

-  BUF->flags = TCP_SYN | TCP_ACK;

-#endif /* UIP_ACTIVE_OPEN */

-  

-  /* We send out the TCP Maximum Segment Size option with our

-     SYNACK. */

-  BUF->optdata[0] = TCP_OPT_MSS;

-  BUF->optdata[1] = TCP_OPT_MSS_LEN;

-  BUF->optdata[2] = (UIP_TCP_MSS) / 256;

-  BUF->optdata[3] = (UIP_TCP_MSS) & 255;

-  uip_len = UIP_IPTCPH_LEN + TCP_OPT_MSS_LEN;

-  BUF->tcpoffset = ((UIP_TCPH_LEN + TCP_OPT_MSS_LEN) / 4) << 4;

-  goto tcp_send;

-

-  /* This label will be jumped to if we found an active connection. */

- found:

-  uip_conn = uip_connr;

-  uip_flags = 0;

-  /* We do a very naive form of TCP reset processing; we just accept

-     any RST and kill our connection. We should in fact check if the

-     sequence number of this reset is wihtin our advertised window

-     before we accept the reset. */

-  if(BUF->flags & TCP_RST) {

-    uip_connr->tcpstateflags = UIP_CLOSED;

-    UIP_LOG("tcp: got reset, aborting connection.");

-    uip_flags = UIP_ABORT;

-    UIP_APPCALL();

-    goto drop;

-  }

-  /* Calculate the length of the data, if the application has sent

-     any data to us. */

-  c = (BUF->tcpoffset >> 4) << 2;

-  /* uip_len will contain the length of the actual TCP data. This is

-     calculated by subtracing the length of the TCP header (in

-     c) and the length of the IP header (20 bytes). */

-  uip_len = uip_len - c - UIP_IPH_LEN;

-

-  /* First, check if the sequence number of the incoming packet is

-     what we're expecting next. If not, we send out an ACK with the

-     correct numbers in. */

-  if(!(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) &&

-       ((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)))) {

-    if((uip_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0)) &&

-       (BUF->seqno[0] != uip_connr->rcv_nxt[0] ||

-	BUF->seqno[1] != uip_connr->rcv_nxt[1] ||

-	BUF->seqno[2] != uip_connr->rcv_nxt[2] ||

-	BUF->seqno[3] != uip_connr->rcv_nxt[3])) {

-      goto tcp_send_ack;

-    }

-  }

-

-  /* Next, check if the incoming segment acknowledges any outstanding

-     data. If so, we update the sequence number, reset the length of

-     the outstanding data, calculate RTT estimations, and reset the

-     retransmission timer. */

-  if((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) {

-    uip_add32(uip_connr->snd_nxt, uip_connr->len);

-

-    if(BUF->ackno[0] == uip_acc32[0] &&

-       BUF->ackno[1] == uip_acc32[1] &&

-       BUF->ackno[2] == uip_acc32[2] &&

-       BUF->ackno[3] == uip_acc32[3]) {

-      /* Update sequence number. */

-      uip_connr->snd_nxt[0] = uip_acc32[0];

-      uip_connr->snd_nxt[1] = uip_acc32[1];

-      uip_connr->snd_nxt[2] = uip_acc32[2];

-      uip_connr->snd_nxt[3] = uip_acc32[3];

-	

-      /* Do RTT estimation, unless we have done retransmissions. */

-      if(uip_connr->nrtx == 0) {

-	signed char m;

-	m = uip_connr->rto - uip_connr->timer;

-	/* This is taken directly from VJs original code in his paper */

-	m = m - (uip_connr->sa >> 3);

-	uip_connr->sa += m;

-	if(m < 0) {

-	  m = -m;

-	}

-	m = m - (uip_connr->sv >> 2);

-	uip_connr->sv += m;

-	uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;

-

-      }

-      /* Set the acknowledged flag. */

-      uip_flags = UIP_ACKDATA;

-      /* Reset the retransmission timer. */

-      uip_connr->timer = uip_connr->rto;

-

-      /* Reset length of outstanding data. */

-      uip_connr->len = 0;

-    }

-    

-  }

-

-  /* Do different things depending on in what state the connection is. */

-  switch(uip_connr->tcpstateflags & UIP_TS_MASK) {

-    /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not

-	implemented, since we force the application to close when the

-	peer sends a FIN (hence the application goes directly from

-	ESTABLISHED to LAST_ACK). */

-  case UIP_SYN_RCVD:

-    /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and

-       we are waiting for an ACK that acknowledges the data we sent

-       out the last time. Therefore, we want to have the UIP_ACKDATA

-       flag set. If so, we enter the ESTABLISHED state. */

-    if(uip_flags & UIP_ACKDATA) {

-      uip_connr->tcpstateflags = UIP_ESTABLISHED;

-      uip_flags = UIP_CONNECTED;

-      uip_connr->len = 0;

-      if(uip_len > 0) {

-        uip_flags |= UIP_NEWDATA;

-        uip_add_rcv_nxt(uip_len);

-      }

-      uip_slen = 0;

-      UIP_APPCALL();

-      goto appsend;

-    }

-    goto drop;

-#if UIP_ACTIVE_OPEN

-  case UIP_SYN_SENT:

-    /* In SYN_SENT, we wait for a SYNACK that is sent in response to

-       our SYN. The rcv_nxt is set to sequence number in the SYNACK

-       plus one, and we send an ACK. We move into the ESTABLISHED

-       state. */

-    if((uip_flags & UIP_ACKDATA) &&

-       (BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)) {

-

-      /* Parse the TCP MSS option, if present. */

-      if((BUF->tcpoffset & 0xf0) > 0x50) {

-	for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {

-	  opt = uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + c];

-	  if(opt == TCP_OPT_END) {

-	    /* End of options. */

-	    break;

-	  } else if(opt == TCP_OPT_NOOP) {

-	    ++c;

-	    /* NOP option. */

-	  } else if(opt == TCP_OPT_MSS &&

-		    uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {

-	    /* An MSS option with the right option length. */

-	    tmp16 = (uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |

-	      uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];

-	    uip_connr->initialmss =

-	      uip_connr->mss = tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;

-

-	    /* And we are done processing options. */

-	    break;

-	  } else {

-	    /* All other options have a length field, so that we easily

-	       can skip past them. */

-	    if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {

-	      /* If the length field is zero, the options are malformed

-		 and we don't process them further. */

-	      break;

-	    }

-	    c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];

-	  }

-	}

-      }

-      uip_connr->tcpstateflags = UIP_ESTABLISHED;

-      uip_connr->rcv_nxt[0] = BUF->seqno[0];

-      uip_connr->rcv_nxt[1] = BUF->seqno[1];

-      uip_connr->rcv_nxt[2] = BUF->seqno[2];

-      uip_connr->rcv_nxt[3] = BUF->seqno[3];

-      uip_add_rcv_nxt(1);

-      uip_flags = UIP_CONNECTED | UIP_NEWDATA;

-      uip_connr->len = 0;

-      uip_len = 0;

-      uip_slen = 0;

-      UIP_APPCALL();

-      goto appsend;

-    }

-    /* Inform the application that the connection failed */

-    uip_flags = UIP_ABORT;

-    UIP_APPCALL();

-    /* The connection is closed after we send the RST */

-    uip_conn->tcpstateflags = UIP_CLOSED;

-    goto reset;

-#endif /* UIP_ACTIVE_OPEN */

-    

-  case UIP_ESTABLISHED:

-    /* In the ESTABLISHED state, we call upon the application to feed

-    data into the uip_buf. If the UIP_ACKDATA flag is set, the

-    application should put new data into the buffer, otherwise we are

-    retransmitting an old segment, and the application should put that

-    data into the buffer.

-

-    If the incoming packet is a FIN, we should close the connection on

-    this side as well, and we send out a FIN and enter the LAST_ACK

-    state. We require that there is no outstanding data; otherwise the

-    sequence numbers will be screwed up. */

-

-    if(BUF->flags & TCP_FIN && !(uip_connr->tcpstateflags & UIP_STOPPED)) {

-      if(uip_outstanding(uip_connr)) {

-	goto drop;

-      }

-      uip_add_rcv_nxt(1 + uip_len);

-      uip_flags |= UIP_CLOSE;

-      if(uip_len > 0) {

-	uip_flags |= UIP_NEWDATA;

-      }

-      UIP_APPCALL();

-      uip_connr->len = 1;

-      uip_connr->tcpstateflags = UIP_LAST_ACK;

-      uip_connr->nrtx = 0;

-    tcp_send_finack:

-      BUF->flags = TCP_FIN | TCP_ACK;

-      goto tcp_send_nodata;

-    }

-

-    /* Check the URG flag. If this is set, the segment carries urgent

-       data that we must pass to the application. */

-    if((BUF->flags & TCP_URG) != 0) {

-#if UIP_URGDATA > 0

-      uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];

-      if(uip_urglen > uip_len) {

-	/* There is more urgent data in the next segment to come. */

-	uip_urglen = uip_len;

-      }

-      uip_add_rcv_nxt(uip_urglen);

-      uip_len -= uip_urglen;

-      uip_urgdata = uip_appdata;

-      uip_appdata += uip_urglen;

-    } else {

-      uip_urglen = 0;

-#else /* UIP_URGDATA > 0 */

-      uip_appdata = ((char *)uip_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]);

-      uip_len -= (BUF->urgp[0] << 8) | BUF->urgp[1];

-#endif /* UIP_URGDATA > 0 */

-    }

-

-    /* If uip_len > 0 we have TCP data in the packet, and we flag this

-       by setting the UIP_NEWDATA flag and update the sequence number

-       we acknowledge. If the application has stopped the dataflow

-       using uip_stop(), we must not accept any data packets from the

-       remote host. */

-    if(uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) {

-      uip_flags |= UIP_NEWDATA;

-      uip_add_rcv_nxt(uip_len);

-    }

-

-    /* Check if the available buffer space advertised by the other end

-       is smaller than the initial MSS for this connection. If so, we

-       set the current MSS to the window size to ensure that the

-       application does not send more data than the other end can

-       handle.

-

-       If the remote host advertises a zero window, we set the MSS to

-       the initial MSS so that the application will send an entire MSS

-       of data. This data will not be acknowledged by the receiver,

-       and the application will retransmit it. This is called the

-       "persistent timer" and uses the retransmission mechanim.

-    */

-    tmp16 = ((u16_t)BUF->wnd[0] << 8) + (u16_t)BUF->wnd[1];

-    if(tmp16 > uip_connr->initialmss ||

-       tmp16 == 0) {

-      tmp16 = uip_connr->initialmss;

-    }

-    uip_connr->mss = tmp16;

-

-    /* If this packet constitutes an ACK for outstanding data (flagged

-       by the UIP_ACKDATA flag, we should call the application since it

-       might want to send more data. If the incoming packet had data

-       from the peer (as flagged by the UIP_NEWDATA flag), the

-       application must also be notified.

-

-       When the application is called, the global variable uip_len

-       contains the length of the incoming data. The application can

-       access the incoming data through the global pointer

-       uip_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN

-       bytes into the uip_buf array.

-

-       If the application wishes to send any data, this data should be

-       put into the uip_appdata and the length of the data should be

-       put into uip_len. If the application don't have any data to

-       send, uip_len must be set to 0. */

-    if(uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) {

-      uip_slen = 0;

-      UIP_APPCALL();

-

-    appsend:

-      

-      if(uip_flags & UIP_ABORT) {

-	uip_slen = 0;

-	uip_connr->tcpstateflags = UIP_CLOSED;

-	BUF->flags = TCP_RST | TCP_ACK;

-	goto tcp_send_nodata;

-      }

-

-      if(uip_flags & UIP_CLOSE) {

-	uip_slen = 0;

-	uip_connr->len = 1;

-	uip_connr->tcpstateflags = UIP_FIN_WAIT_1;

-	uip_connr->nrtx = 0;

-	BUF->flags = TCP_FIN | TCP_ACK;

-	goto tcp_send_nodata;

-      }

-

-      /* If uip_slen > 0, the application has data to be sent. */

-      if(uip_slen > 0) {

-

-	/* If the connection has acknowledged data, the contents of

-	   the ->len variable should be discarded. */

-	if((uip_flags & UIP_ACKDATA) != 0) {

-	  uip_connr->len = 0;

-	}

-

-	/* If the ->len variable is non-zero the connection has

-	   already data in transit and cannot send anymore right

-	   now. */

-	if(uip_connr->len == 0) {

-

-	  /* The application cannot send more than what is allowed by

-	     the mss (the minumum of the MSS and the available

-	     window). */

-	  if(uip_slen > uip_connr->mss) {

-	    uip_slen = uip_connr->mss;

-	  }

-

-	  /* Remember how much data we send out now so that we know

-	     when everything has been acknowledged. */

-	  uip_connr->len = uip_slen;

-	} else {

-

-	  /* If the application already had unacknowledged data, we

-	     make sure that the application does not send (i.e.,

-	     retransmit) out more than it previously sent out. */

-	  uip_slen = uip_connr->len;

-	}

-      }

-      uip_connr->nrtx = 0;

-    apprexmit:

-      uip_appdata = uip_sappdata;

-      

-      /* If the application has data to be sent, or if the incoming

-         packet had new data in it, we must send out a packet. */

-      if(uip_slen > 0 && uip_connr->len > 0) {

-	/* Add the length of the IP and TCP headers. */

-	uip_len = uip_connr->len + UIP_TCPIP_HLEN;

-	/* We always set the ACK flag in response packets. */

-	BUF->flags = TCP_ACK | TCP_PSH;

-	/* Send the packet. */

-	goto tcp_send_noopts;

-      }

-      /* If there is no data to send, just send out a pure ACK if

-	 there is newdata. */

-      if(uip_flags & UIP_NEWDATA) {

-	uip_len = UIP_TCPIP_HLEN;

-	BUF->flags = TCP_ACK;

-	goto tcp_send_noopts;

-      }

-    }

-    goto drop;

-  case UIP_LAST_ACK:

-    /* We can close this connection if the peer has acknowledged our

-       FIN. This is indicated by the UIP_ACKDATA flag. */

-    if(uip_flags & UIP_ACKDATA) {

-      uip_connr->tcpstateflags = UIP_CLOSED;

-      uip_flags = UIP_CLOSE;

-      UIP_APPCALL();

-    }

-    break;

-    

-  case UIP_FIN_WAIT_1:

-    /* The application has closed the connection, but the remote host

-       hasn't closed its end yet. Thus we do nothing but wait for a

-       FIN from the other side. */

-    if(uip_len > 0) {

-      uip_add_rcv_nxt(uip_len);

-    }

-    if(BUF->flags & TCP_FIN) {

-      if(uip_flags & UIP_ACKDATA) {

-	uip_connr->tcpstateflags = UIP_TIME_WAIT;

-	uip_connr->timer = 0;

-	uip_connr->len = 0;

-      } else {

-	uip_connr->tcpstateflags = UIP_CLOSING;

-      }

-      uip_add_rcv_nxt(1);

-      uip_flags = UIP_CLOSE;

-      UIP_APPCALL();

-      goto tcp_send_ack;

-    } else if(uip_flags & UIP_ACKDATA) {

-      uip_connr->tcpstateflags = UIP_FIN_WAIT_2;

-      uip_connr->len = 0;

-      goto drop;

-    }

-    if(uip_len > 0) {

-      goto tcp_send_ack;

-    }

-    goto drop;

-      

-  case UIP_FIN_WAIT_2:

-    if(uip_len > 0) {

-      uip_add_rcv_nxt(uip_len);

-    }

-    if(BUF->flags & TCP_FIN) {

-      uip_connr->tcpstateflags = UIP_TIME_WAIT;

-      uip_connr->timer = 0;

-      uip_add_rcv_nxt(1);

-      uip_flags = UIP_CLOSE;

-      UIP_APPCALL();

-      goto tcp_send_ack;

-    }

-    if(uip_len > 0) {

-      goto tcp_send_ack;

-    }

-    goto drop;

-

-  case UIP_TIME_WAIT:

-    goto tcp_send_ack;

-    

-  case UIP_CLOSING:

-    if(uip_flags & UIP_ACKDATA) {

-      uip_connr->tcpstateflags = UIP_TIME_WAIT;

-      uip_connr->timer = 0;

-    }

-  }

-  goto drop;

-  

-  /* We jump here when we are ready to send the packet, and just want

-     to set the appropriate TCP sequence numbers in the TCP header. */

- tcp_send_ack:

-  BUF->flags = TCP_ACK;

-

- tcp_send_nodata:

-  uip_len = UIP_IPTCPH_LEN;

-

- tcp_send_noopts:

-  BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4;

-

-  /* We're done with the input processing. We are now ready to send a

-     reply. Our job is to fill in all the fields of the TCP and IP

-     headers before calculating the checksum and finally send the

-     packet. */

- tcp_send:

-  BUF->ackno[0] = uip_connr->rcv_nxt[0];

-  BUF->ackno[1] = uip_connr->rcv_nxt[1];

-  BUF->ackno[2] = uip_connr->rcv_nxt[2];

-  BUF->ackno[3] = uip_connr->rcv_nxt[3];

-  

-  BUF->seqno[0] = uip_connr->snd_nxt[0];

-  BUF->seqno[1] = uip_connr->snd_nxt[1];

-  BUF->seqno[2] = uip_connr->snd_nxt[2];

-  BUF->seqno[3] = uip_connr->snd_nxt[3];

-

-  BUF->proto = UIP_PROTO_TCP;

-  

-  BUF->srcport  = uip_connr->lport;

-  BUF->destport = uip_connr->rport;

-

-  uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);

-  uip_ipaddr_copy(&BUF->destipaddr, &uip_connr->ripaddr);

-

-  if(uip_connr->tcpstateflags & UIP_STOPPED) {

-    /* If the connection has issued uip_stop(), we advertise a zero

-       window so that the remote host will stop sending data. */

-    BUF->wnd[0] = BUF->wnd[1] = 0;

-  } else {

-    BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);

-    BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff);

-  }

-

- tcp_send_noconn:

-  BUF->ttl = UIP_TTL;

-#if UIP_CONF_IPV6

-  /* For IPv6, the IP length field does not include the IPv6 IP header

-     length. */

-  BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);

-  BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);

-#else /* UIP_CONF_IPV6 */

-  BUF->len[0] = (uip_len >> 8);

-  BUF->len[1] = (uip_len & 0xff);

-#endif /* UIP_CONF_IPV6 */

-

-  BUF->urgp[0] = BUF->urgp[1] = 0;

-  

-  /* Calculate TCP checksum. */

-  BUF->tcpchksum = 0;

-  BUF->tcpchksum = ~(uip_tcpchksum());

-

- ip_send_nolen:

-#if UIP_CONF_IPV6

-  BUF->vtc = 0x60;

-  BUF->tcflow = 0x00;

-  BUF->flow = 0x00;

-#else /* UIP_CONF_IPV6 */

-  BUF->vhl = 0x45;

-  BUF->tos = 0;

-  BUF->ipoffset[0] = BUF->ipoffset[1] = 0;

-  ++ipid;

-  BUF->ipid[0] = ipid >> 8;

-  BUF->ipid[1] = ipid & 0xff;

-  /* Calculate IP checksum. */

-  BUF->ipchksum = 0;

-  BUF->ipchksum = ~(uip_ipchksum());

-  DEBUG_PRINTF("uip ip_send_nolen: chkecum 0x%04x\n", uip_ipchksum());

-#endif /* UIP_CONF_IPV6 */   

-  UIP_STAT(++uip_stat.tcp.sent);

-#if UIP_CONF_IPV6

- send:

-#endif /* UIP_CONF_IPV6 */

-  DEBUG_PRINTF("Sending packet with length %d (%d)\n", uip_len,

-	       (BUF->len[0] << 8) | BUF->len[1]);

-  

-  UIP_STAT(++uip_stat.ip.sent);

-  /* Return and let the caller do the actual transmission. */

-  uip_flags = 0;

-  return;

-

- drop:

-  uip_len = 0;

-  uip_flags = 0;

-  return;

-}

-/*---------------------------------------------------------------------------*/

-u16_t

-htons(u16_t val)

-{

-  return HTONS(val);

-}

-

-u32_t

-htonl(u32_t val)

-{

-  return HTONL(val);

-}

-/*---------------------------------------------------------------------------*/

-void

-uip_send(const void *data, int len)

-{

-  int copylen;

-#define MIN(a,b) ((a) < (b)? (a): (b))

-  copylen = MIN(len, UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN -

-		(int)((char *)uip_sappdata - (char *)&uip_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN]));

-  if(copylen > 0) {

-    uip_slen = copylen;

-    if(data != uip_sappdata) {

-      memcpy(uip_sappdata, (data), uip_slen);

-    }

-  }

-}

-/*---------------------------------------------------------------------------*/

-/** @} */

-#endif /* UIP_CONF_IPV6 */

+#define DEBUG_PRINTF(...) /*printf(__VA_ARGS__)*/
+
+/**
+ * \addtogroup uip
+ * @{
+ */
+
+/**
+ * \file
+ * The uIP TCP/IP stack code.
+ * \author Adam Dunkels <adam@dunkels.com>
+ */
+
+/*
+ * Copyright (c) 2001-2003, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uip.c,v 1.15 2008/10/15 08:08:32 adamdunkels Exp $
+ *
+ */
+
+/*
+ * uIP is a small implementation of the IP, UDP and TCP protocols (as
+ * well as some basic ICMP stuff). The implementation couples the IP,
+ * UDP, TCP and the application layers very tightly. To keep the size
+ * of the compiled code down, this code frequently uses the goto
+ * statement. While it would be possible to break the uip_process()
+ * function into many smaller functions, this would increase the code
+ * size because of the overhead of parameter passing and the fact that
+ * the optimier would not be as efficient.
+ *
+ * The principle is that we have a small buffer, called the uip_buf,
+ * in which the device driver puts an incoming packet. The TCP/IP
+ * stack parses the headers in the packet, and calls the
+ * application. If the remote host has sent data to the application,
+ * this data is present in the uip_buf and the application read the
+ * data from there. It is up to the application to put this data into
+ * a byte stream if needed. The application will not be fed with data
+ * that is out of sequence.
+ *
+ * If the application whishes to send data to the peer, it should put
+ * its data into the uip_buf. The uip_appdata pointer points to the
+ * first available byte. The TCP/IP stack will calculate the
+ * checksums, and fill in the necessary header fields and finally send
+ * the packet back to the peer.
+*/
+
+#include "uip.h"
+#include "uipopt.h"
+#include "uip_arp.h"
+
+#if !UIP_CONF_IPV6 /* If UIP_CONF_IPV6 is defined, we compile the
+		      uip6.c file instead of this one. Therefore
+		      this #ifndef removes the entire compilation
+		      output of the uip.c file */
+
+
+#if UIP_CONF_IPV6
+#include "net/uip-neighbor.h"
+#endif /* UIP_CONF_IPV6 */
+
+#include <string.h>
+
+/*---------------------------------------------------------------------------*/
+/* Variable definitions. */
+
+
+/* The IP address of this host. If it is defined to be fixed (by
+   setting UIP_FIXEDADDR to 1 in uipopt.h), the address is set
+   here. Otherwise, the address */
+#if UIP_FIXEDADDR > 0
+const uip_ipaddr_t uip_hostaddr =
+  { UIP_IPADDR0, UIP_IPADDR1, UIP_IPADDR2, UIP_IPADDR3 };
+const uip_ipaddr_t uip_draddr =
+  { UIP_DRIPADDR0, UIP_DRIPADDR1, UIP_DRIPADDR2, UIP_DRIPADDR3 };
+const uip_ipaddr_t uip_netmask =
+  { UIP_NETMASK0, UIP_NETMASK1, UIP_NETMASK2, UIP_NETMASK3 };
+#else
+uip_ipaddr_t uip_hostaddr, uip_draddr, uip_netmask;
+#endif /* UIP_FIXEDADDR */
+
+const uip_ipaddr_t uip_broadcast_addr =
+#if UIP_CONF_IPV6
+  { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } };
+#else /* UIP_CONF_IPV6 */
+  { { 0xff, 0xff, 0xff, 0xff } };
+#endif /* UIP_CONF_IPV6 */
+const uip_ipaddr_t uip_all_zeroes_addr = { { 0x0, /* rest is 0 */ } };
+
+#if UIP_FIXEDETHADDR
+const struct uip_eth_addr uip_ethaddr = {{UIP_ETHADDR0,
+					  UIP_ETHADDR1,
+					  UIP_ETHADDR2,
+					  UIP_ETHADDR3,
+					  UIP_ETHADDR4,
+					  UIP_ETHADDR5}};
+#else
+struct uip_eth_addr uip_ethaddr = {{0,0,0,0,0,0}};
+#endif
+
+#ifndef UIP_CONF_EXTERNAL_BUFFER
+u8_t uip_buf[UIP_BUFSIZE + 2];   /* The packet buffer that contains
+				    incoming packets. */
+#endif /* UIP_CONF_EXTERNAL_BUFFER */
+
+void *uip_appdata;               /* The uip_appdata pointer points to
+				    application data. */
+void *uip_sappdata;              /* The uip_appdata pointer points to
+				    the application data which is to
+				    be sent. */
+#if UIP_URGDATA > 0
+void *uip_urgdata;               /* The uip_urgdata pointer points to
+   				    urgent data (out-of-band data), if
+   				    present. */
+u16_t uip_urglen, uip_surglen;
+#endif /* UIP_URGDATA > 0 */
+
+u16_t uip_len, uip_slen;
+                             /* The uip_len is either 8 or 16 bits,
+				depending on the maximum packet
+				size. */
+
+u8_t uip_flags;     /* The uip_flags variable is used for
+				communication between the TCP/IP stack
+				and the application program. */
+struct uip_conn *uip_conn;   /* uip_conn always points to the current
+				connection. */
+
+struct uip_conn uip_conns[UIP_CONNS];
+                             /* The uip_conns array holds all TCP
+				connections. */
+u16_t uip_listenports[UIP_LISTENPORTS];
+                             /* The uip_listenports list all currently
+				listning ports. */
+#if UIP_UDP
+struct uip_udp_conn *uip_udp_conn;
+struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
+#endif /* UIP_UDP */
+
+static u16_t ipid;           /* Ths ipid variable is an increasing
+				number that is used for the IP ID
+				field. */
+
+void uip_setipid(u16_t id) { ipid = id; }
+
+static u8_t iss[4];          /* The iss variable is used for the TCP
+				initial sequence number. */
+
+#if UIP_ACTIVE_OPEN
+static u16_t lastport;       /* Keeps track of the last port used for
+				a new connection. */
+#endif /* UIP_ACTIVE_OPEN */
+
+/* Temporary variables. */
+u8_t uip_acc32[4];
+static u8_t c, opt;
+static u16_t tmp16;
+
+/* Structures and definitions. */
+#define TCP_FIN 0x01
+#define TCP_SYN 0x02
+#define TCP_RST 0x04
+#define TCP_PSH 0x08
+#define TCP_ACK 0x10
+#define TCP_URG 0x20
+#define TCP_CTL 0x3f
+
+#define TCP_OPT_END     0   /* End of TCP options list */
+#define TCP_OPT_NOOP    1   /* "No-operation" TCP option */
+#define TCP_OPT_MSS     2   /* Maximum segment size TCP option */
+
+#define TCP_OPT_MSS_LEN 4   /* Length of TCP MSS option. */
+
+#define ICMP_ECHO_REPLY 0
+#define ICMP_ECHO       8
+
+#define ICMP_DEST_UNREACHABLE        3
+#define ICMP_PORT_UNREACHABLE        3
+
+#define ICMP6_ECHO_REPLY             129
+#define ICMP6_ECHO                   128
+#define ICMP6_NEIGHBOR_SOLICITATION  135
+#define ICMP6_NEIGHBOR_ADVERTISEMENT 136
+
+#define ICMP6_FLAG_S (1 << 6)
+
+#define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1
+#define ICMP6_OPTION_TARGET_LINK_ADDRESS 2
+
+
+/* Macros. */
+#define BUF ((struct uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])
+#define FBUF ((struct uip_tcpip_hdr *)&uip_reassbuf[0])
+#define ICMPBUF ((struct uip_icmpip_hdr *)&uip_buf[UIP_LLH_LEN])
+#define UDPBUF ((struct uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])
+
+
+#if UIP_STATISTICS == 1
+struct uip_stats uip_stat;
+#define UIP_STAT(s) s
+#else
+#define UIP_STAT(s)
+#endif /* UIP_STATISTICS == 1 */
+
+#if UIP_LOGGING == 1
+#include <stdio.h>
+void uip_log(char *msg);
+#define UIP_LOG(m) uip_log(m)
+#else
+#define UIP_LOG(m)
+#endif /* UIP_LOGGING == 1 */
+
+#if ! UIP_ARCH_ADD32
+void
+uip_add32(u8_t *op32, u16_t op16)
+{
+  uip_acc32[3] = op32[3] + (op16 & 0xff);
+  uip_acc32[2] = op32[2] + (op16 >> 8);
+  uip_acc32[1] = op32[1];
+  uip_acc32[0] = op32[0];
+  
+  if(uip_acc32[2] < (op16 >> 8)) {
+    ++uip_acc32[1];
+    if(uip_acc32[1] == 0) {
+      ++uip_acc32[0];
+    }
+  }
+  
+  
+  if(uip_acc32[3] < (op16 & 0xff)) {
+    ++uip_acc32[2];
+    if(uip_acc32[2] == 0) {
+      ++uip_acc32[1];
+      if(uip_acc32[1] == 0) {
+	++uip_acc32[0];
+      }
+    }
+  }
+}
+
+#endif /* UIP_ARCH_ADD32 */
+
+#if ! UIP_ARCH_CHKSUM
+/*---------------------------------------------------------------------------*/
+static u16_t
+chksum(u16_t sum, const u8_t *data, u16_t len)
+{
+  u16_t t;
+  const u8_t *dataptr;
+  const u8_t *last_byte;
+
+  dataptr = data;
+  last_byte = data + len - 1;
+  
+  while(dataptr < last_byte) {	/* At least two more bytes */
+    t = (dataptr[0] << 8) + dataptr[1];
+    sum += t;
+    if(sum < t) {
+      sum++;		/* carry */
+    }
+    dataptr += 2;
+  }
+  
+  if(dataptr == last_byte) {
+    t = (dataptr[0] << 8) + 0;
+    sum += t;
+    if(sum < t) {
+      sum++;		/* carry */
+    }
+  }
+
+  /* Return sum in host byte order. */
+  return sum;
+}
+/*---------------------------------------------------------------------------*/
+u16_t
+uip_chksum(u16_t *data, u16_t len)
+{
+  return htons(chksum(0, (u8_t *)data, len));
+}
+/*---------------------------------------------------------------------------*/
+#ifndef UIP_ARCH_IPCHKSUM
+u16_t
+uip_ipchksum(void)
+{
+  u16_t sum;
+
+  sum = chksum(0, &uip_buf[UIP_LLH_LEN], UIP_IPH_LEN);
+  DEBUG_PRINTF("uip_ipchksum: sum 0x%04x\n", sum);
+  return (sum == 0) ? 0xffff : htons(sum);
+}
+#endif
+/*---------------------------------------------------------------------------*/
+static u16_t
+upper_layer_chksum(u8_t proto)
+{
+  u16_t upper_layer_len;
+  u16_t sum;
+  
+#if UIP_CONF_IPV6
+  upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]);
+#else /* UIP_CONF_IPV6 */
+  upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]) - UIP_IPH_LEN;
+#endif /* UIP_CONF_IPV6 */
+  
+  /* First sum pseudoheader. */
+  
+  /* IP protocol and length fields. This addition cannot carry. */
+  sum = upper_layer_len + proto;
+  /* Sum IP source and destination addresses. */
+  sum = chksum(sum, (u8_t *)&BUF->srcipaddr, 2 * sizeof(uip_ipaddr_t));
+
+  /* Sum TCP header and data. */
+  sum = chksum(sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN],
+	       upper_layer_len);
+    
+  return (sum == 0) ? 0xffff : htons(sum);
+}
+/*---------------------------------------------------------------------------*/
+#if UIP_CONF_IPV6
+u16_t
+uip_icmp6chksum(void)
+{
+  return upper_layer_chksum(UIP_PROTO_ICMP6);
+  
+}
+#endif /* UIP_CONF_IPV6 */
+/*---------------------------------------------------------------------------*/
+u16_t
+uip_tcpchksum(void)
+{
+  return upper_layer_chksum(UIP_PROTO_TCP);
+}
+/*---------------------------------------------------------------------------*/
+#if UIP_UDP_CHECKSUMS
+u16_t
+uip_udpchksum(void)
+{
+  return upper_layer_chksum(UIP_PROTO_UDP);
+}
+#endif /* UIP_UDP_CHECKSUMS */
+#endif /* UIP_ARCH_CHKSUM */
+/*---------------------------------------------------------------------------*/
+void
+uip_init(void)
+{
+  for(c = 0; c < UIP_LISTENPORTS; ++c) {
+    uip_listenports[c] = 0;
+  }
+  for(c = 0; c < UIP_CONNS; ++c) {
+    uip_conns[c].tcpstateflags = UIP_CLOSED;
+  }
+#if UIP_ACTIVE_OPEN
+  lastport = 1024;
+#endif /* UIP_ACTIVE_OPEN */
+
+#if UIP_UDP
+  for(c = 0; c < UIP_UDP_CONNS; ++c) {
+    uip_udp_conns[c].lport = 0;
+  }
+#endif /* UIP_UDP */
+  
+
+  /* IPv4 initialization. */
+#if UIP_FIXEDADDR == 0
+  /*  uip_hostaddr[0] = uip_hostaddr[1] = 0;*/
+#endif /* UIP_FIXEDADDR */
+
+}
+/*---------------------------------------------------------------------------*/
+#if UIP_ACTIVE_OPEN
+struct uip_conn *
+uip_connect(uip_ipaddr_t *ripaddr, u16_t rport)
+{
+  register struct uip_conn *conn, *cconn;
+  
+  /* Find an unused local port. */
+ again:
+  ++lastport;
+
+  if(lastport >= 32000) {
+    lastport = 4096;
+  }
+
+  /* Check if this port is already in use, and if so try to find
+     another one. */
+  for(c = 0; c < UIP_CONNS; ++c) {
+    conn = &uip_conns[c];
+    if(conn->tcpstateflags != UIP_CLOSED &&
+       conn->lport == htons(lastport)) {
+      goto again;
+    }
+  }
+
+  conn = 0;
+  for(c = 0; c < UIP_CONNS; ++c) {
+    cconn = &uip_conns[c];
+    if(cconn->tcpstateflags == UIP_CLOSED) {
+      conn = cconn;
+      break;
+    }
+    if(cconn->tcpstateflags == UIP_TIME_WAIT) {
+      if(conn == 0 ||
+	 cconn->timer > conn->timer) {
+	conn = cconn;
+      }
+    }
+  }
+
+  if(conn == 0) {
+    return 0;
+  }
+  
+  conn->tcpstateflags = UIP_SYN_SENT;
+
+  conn->snd_nxt[0] = iss[0];
+  conn->snd_nxt[1] = iss[1];
+  conn->snd_nxt[2] = iss[2];
+  conn->snd_nxt[3] = iss[3];
+
+  conn->initialmss = conn->mss = UIP_TCP_MSS;
+  
+  conn->len = 1;   /* TCP length of the SYN is one. */
+  conn->nrtx = 0;
+  conn->timer = 1; /* Send the SYN next time around. */
+  conn->rto = UIP_RTO;
+  conn->sa = 0;
+  conn->sv = 16;   /* Initial value of the RTT variance. */
+  conn->lport = htons(lastport);
+  conn->rport = rport;
+  uip_ipaddr_copy(&conn->ripaddr, ripaddr);
+  
+  return conn;
+}
+#endif /* UIP_ACTIVE_OPEN */
+/*---------------------------------------------------------------------------*/
+#if UIP_UDP
+struct uip_udp_conn *
+uip_udp_new(const uip_ipaddr_t *ripaddr, u16_t rport)
+{
+  register struct uip_udp_conn *conn;
+  
+  /* Find an unused local port. */
+ again:
+  ++lastport;
+
+  if(lastport >= 32000) {
+    lastport = 4096;
+  }
+  
+  for(c = 0; c < UIP_UDP_CONNS; ++c) {
+    if(uip_udp_conns[c].lport == htons(lastport)) {
+      goto again;
+    }
+  }
+
+
+  conn = 0;
+  for(c = 0; c < UIP_UDP_CONNS; ++c) {
+    if(uip_udp_conns[c].lport == 0) {
+      conn = &uip_udp_conns[c];
+      break;
+    }
+  }
+
+  if(conn == 0) {
+    return 0;
+  }
+  
+  conn->lport = HTONS(lastport);
+  conn->rport = rport;
+  if(ripaddr == NULL) {
+    memset(&conn->ripaddr, 0, sizeof(uip_ipaddr_t));
+  } else {
+    uip_ipaddr_copy(&conn->ripaddr, ripaddr);
+  }
+  conn->ttl = UIP_TTL;
+  
+  return conn;
+}
+#endif /* UIP_UDP */
+/*---------------------------------------------------------------------------*/
+void
+uip_unlisten(u16_t port)
+{
+  for(c = 0; c < UIP_LISTENPORTS; ++c) {
+    if(uip_listenports[c] == port) {
+      uip_listenports[c] = 0;
+      return;
+    }
+  }
+}
+/*---------------------------------------------------------------------------*/
+void
+uip_listen(u16_t port)
+{
+  for(c = 0; c < UIP_LISTENPORTS; ++c) {
+    if(uip_listenports[c] == 0) {
+      uip_listenports[c] = port;
+      return;
+    }
+  }
+}
+/*---------------------------------------------------------------------------*/
+/* XXX: IP fragment reassembly: not well-tested. */
+
+#if UIP_REASSEMBLY && !UIP_CONF_IPV6
+#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)
+static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];
+static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];
+static const u8_t bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f,
+				    0x0f, 0x07, 0x03, 0x01};
+static u16_t uip_reasslen;
+static u8_t uip_reassflags;
+#define UIP_REASS_FLAG_LASTFRAG 0x01
+static u8_t uip_reasstmr;
+
+#define IP_MF   0x20
+
+static u8_t
+uip_reass(void)
+{
+  u16_t offset, len;
+  u16_t i;
+
+  /* If ip_reasstmr is zero, no packet is present in the buffer, so we
+     write the IP header of the fragment into the reassembly
+     buffer. The timer is updated with the maximum age. */
+  if(uip_reasstmr == 0) {
+    memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN);
+    uip_reasstmr = UIP_REASS_MAXAGE;
+    uip_reassflags = 0;
+    /* Clear the bitmap. */
+    memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap));
+  }
+
+  /* Check if the incoming fragment matches the one currently present
+     in the reasembly buffer. If so, we proceed with copying the
+     fragment into the buffer. */
+  if(BUF->srcipaddr[0] == FBUF->srcipaddr[0] &&
+     BUF->srcipaddr[1] == FBUF->srcipaddr[1] &&
+     BUF->destipaddr[0] == FBUF->destipaddr[0] &&
+     BUF->destipaddr[1] == FBUF->destipaddr[1] &&
+     BUF->ipid[0] == FBUF->ipid[0] &&
+     BUF->ipid[1] == FBUF->ipid[1]) {
+
+    len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
+    offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;
+
+    /* If the offset or the offset + fragment length overflows the
+       reassembly buffer, we discard the entire packet. */
+    if(offset > UIP_REASS_BUFSIZE ||
+       offset + len > UIP_REASS_BUFSIZE) {
+      uip_reasstmr = 0;
+      goto nullreturn;
+    }
+
+    /* Copy the fragment into the reassembly buffer, at the right
+       offset. */
+    memcpy(&uip_reassbuf[UIP_IPH_LEN + offset],
+	   (char *)BUF + (int)((BUF->vhl & 0x0f) * 4),
+	   len);
+      
+    /* Update the bitmap. */
+    if(offset / (8 * 8) == (offset + len) / (8 * 8)) {
+      /* If the two endpoints are in the same byte, we only update
+	 that byte. */
+	     
+      uip_reassbitmap[offset / (8 * 8)] |=
+	     bitmap_bits[(offset / 8 ) & 7] &
+	     ~bitmap_bits[((offset + len) / 8 ) & 7];
+    } else {
+      /* If the two endpoints are in different bytes, we update the
+	 bytes in the endpoints and fill the stuff inbetween with
+	 0xff. */
+      uip_reassbitmap[offset / (8 * 8)] |=
+	bitmap_bits[(offset / 8 ) & 7];
+      for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {
+	uip_reassbitmap[i] = 0xff;
+      }
+      uip_reassbitmap[(offset + len) / (8 * 8)] |=
+	~bitmap_bits[((offset + len) / 8 ) & 7];
+    }
+    
+    /* If this fragment has the More Fragments flag set to zero, we
+       know that this is the last fragment, so we can calculate the
+       size of the entire packet. We also set the
+       IP_REASS_FLAG_LASTFRAG flag to indicate that we have received
+       the final fragment. */
+
+    if((BUF->ipoffset[0] & IP_MF) == 0) {
+      uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;
+      uip_reasslen = offset + len;
+    }
+    
+    /* Finally, we check if we have a full packet in the buffer. We do
+       this by checking if we have the last fragment and if all bits
+       in the bitmap are set. */
+    if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {
+      /* Check all bytes up to and including all but the last byte in
+	 the bitmap. */
+      for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {
+	if(uip_reassbitmap[i] != 0xff) {
+	  goto nullreturn;
+	}
+      }
+      /* Check the last byte in the bitmap. It should contain just the
+	 right amount of bits. */
+      if(uip_reassbitmap[uip_reasslen / (8 * 8)] !=
+	 (u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {
+	goto nullreturn;
+      }
+
+      /* If we have come this far, we have a full packet in the
+	 buffer, so we allocate a pbuf and copy the packet into it. We
+	 also reset the timer. */
+      uip_reasstmr = 0;
+      memcpy(BUF, FBUF, uip_reasslen);
+
+      /* Pretend to be a "normal" (i.e., not fragmented) IP packet
+	 from now on. */
+      BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
+      BUF->len[0] = uip_reasslen >> 8;
+      BUF->len[1] = uip_reasslen & 0xff;
+      BUF->ipchksum = 0;
+      BUF->ipchksum = ~(uip_ipchksum());
+
+      return uip_reasslen;
+    }
+  }
+
+ nullreturn:
+  return 0;
+}
+#endif /* UIP_REASSEMBLY */
+/*---------------------------------------------------------------------------*/
+static void
+uip_add_rcv_nxt(u16_t n)
+{
+  uip_add32(uip_conn->rcv_nxt, n);
+  uip_conn->rcv_nxt[0] = uip_acc32[0];
+  uip_conn->rcv_nxt[1] = uip_acc32[1];
+  uip_conn->rcv_nxt[2] = uip_acc32[2];
+  uip_conn->rcv_nxt[3] = uip_acc32[3];
+}
+/*---------------------------------------------------------------------------*/
+void
+uip_process(u8_t flag)
+{
+  register struct uip_conn *uip_connr = uip_conn;
+
+#if UIP_UDP
+  if(flag == UIP_UDP_SEND_CONN) {
+    goto udp_send;
+  }
+#endif /* UIP_UDP */
+  
+  uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
+
+  /* Check if we were invoked because of a poll request for a
+     particular connection. */
+  if(flag == UIP_POLL_REQUEST) {
+    if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED &&
+       !uip_outstanding(uip_connr)) {
+	uip_len = uip_slen = 0;
+	uip_flags = UIP_POLL;
+	UIP_APPCALL();
+	goto appsend;
+    }
+    goto drop;
+    
+    /* Check if we were invoked because of the perodic timer fireing. */
+  } else if(flag == UIP_TIMER) {
+#if UIP_REASSEMBLY
+    if(uip_reasstmr != 0) {
+      --uip_reasstmr;
+    }
+#endif /* UIP_REASSEMBLY */
+    /* Increase the initial sequence number. */
+    if(++iss[3] == 0) {
+      if(++iss[2] == 0) {
+	if(++iss[1] == 0) {
+	  ++iss[0];
+	}
+      }
+    }
+
+    /* Reset the length variables. */
+    uip_len = 0;
+    uip_slen = 0;
+
+    /* Check if the connection is in a state in which we simply wait
+       for the connection to time out. If so, we increase the
+       connection's timer and remove the connection if it times
+       out. */
+    if(uip_connr->tcpstateflags == UIP_TIME_WAIT ||
+       uip_connr->tcpstateflags == UIP_FIN_WAIT_2) {
+      ++(uip_connr->timer);
+      if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {
+	uip_connr->tcpstateflags = UIP_CLOSED;
+      }
+    } else if(uip_connr->tcpstateflags != UIP_CLOSED) {
+      /* If the connection has outstanding data, we increase the
+	 connection's timer and see if it has reached the RTO value
+	 in which case we retransmit. */
+      if(uip_outstanding(uip_connr)) {
+	if(uip_connr->timer-- == 0) {
+	  if(uip_connr->nrtx == UIP_MAXRTX ||
+	     ((uip_connr->tcpstateflags == UIP_SYN_SENT ||
+	       uip_connr->tcpstateflags == UIP_SYN_RCVD) &&
+	      uip_connr->nrtx == UIP_MAXSYNRTX)) {
+	    uip_connr->tcpstateflags = UIP_CLOSED;
+
+	    /* We call UIP_APPCALL() with uip_flags set to
+	       UIP_TIMEDOUT to inform the application that the
+	       connection has timed out. */
+	    uip_flags = UIP_TIMEDOUT;
+	    UIP_APPCALL();
+
+	    /* We also send a reset packet to the remote host. */
+	    BUF->flags = TCP_RST | TCP_ACK;
+	    goto tcp_send_nodata;
+	  }
+
+	  /* Exponential backoff. */
+	  uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4?
+					 4:
+					 uip_connr->nrtx);
+	  ++(uip_connr->nrtx);
+	  
+	  /* Ok, so we need to retransmit. We do this differently
+	     depending on which state we are in. In ESTABLISHED, we
+	     call upon the application so that it may prepare the
+	     data for the retransmit. In SYN_RCVD, we resend the
+	     SYNACK that we sent earlier and in LAST_ACK we have to
+	     retransmit our FINACK. */
+	  UIP_STAT(++uip_stat.tcp.rexmit);
+	  switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
+	  case UIP_SYN_RCVD:
+	    /* In the SYN_RCVD state, we should retransmit our
+               SYNACK. */
+	    goto tcp_send_synack;
+	    
+#if UIP_ACTIVE_OPEN
+	  case UIP_SYN_SENT:
+	    /* In the SYN_SENT state, we retransmit out SYN. */
+	    BUF->flags = 0;
+	    goto tcp_send_syn;
+#endif /* UIP_ACTIVE_OPEN */
+	    
+	  case UIP_ESTABLISHED:
+	    /* In the ESTABLISHED state, we call upon the application
+               to do the actual retransmit after which we jump into
+               the code for sending out the packet (the apprexmit
+               label). */
+	    uip_flags = UIP_REXMIT;
+	    UIP_APPCALL();
+	    goto apprexmit;
+	    
+	  case UIP_FIN_WAIT_1:
+	  case UIP_CLOSING:
+	  case UIP_LAST_ACK:
+	    /* In all these states we should retransmit a FINACK. */
+	    goto tcp_send_finack;
+	    
+	  }
+	}
+      } else if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED) {
+	/* If there was no need for a retransmission, we poll the
+           application for new data. */
+	uip_len = uip_slen = 0;		   
+	uip_flags = UIP_POLL;
+	UIP_APPCALL();
+	goto appsend;
+      }
+    }
+    goto drop;
+  }
+#if UIP_UDP
+  if(flag == UIP_UDP_TIMER) {
+    if(uip_udp_conn->lport != 0) {
+      uip_conn = NULL;
+      uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+      uip_len = uip_slen = 0;
+      uip_flags = UIP_POLL;
+      UIP_UDP_APPCALL();
+      goto udp_send;
+    } else {
+      goto drop;
+    }
+  }
+#endif
+
+  /* This is where the input processing starts. */
+  UIP_STAT(++uip_stat.ip.recv);
+
+  /* Start of IP input header processing code. */
+  
+#if UIP_CONF_IPV6
+  /* Check validity of the IP header. */
+  if((BUF->vtc & 0xf0) != 0x60)  { /* IP version and header length. */
+    UIP_STAT(++uip_stat.ip.drop);
+    UIP_STAT(++uip_stat.ip.vhlerr);
+    UIP_LOG("ipv6: invalid version.");
+    goto drop;
+  }
+#else /* UIP_CONF_IPV6 */
+  /* Check validity of the IP header. */
+  if(BUF->vhl != 0x45)  { /* IP version and header length. */
+    UIP_STAT(++uip_stat.ip.drop);
+    UIP_STAT(++uip_stat.ip.vhlerr);
+    UIP_LOG("ip: invalid version or header length.");
+    goto drop;
+  }
+#endif /* UIP_CONF_IPV6 */
+  
+  /* Check the size of the packet. If the size reported to us in
+     uip_len is smaller the size reported in the IP header, we assume
+     that the packet has been corrupted in transit. If the size of
+     uip_len is larger than the size reported in the IP packet header,
+     the packet has been padded and we set uip_len to the correct
+     value.. */
+
+  if((BUF->len[0] << 8) + BUF->len[1] <= uip_len) {
+    uip_len = (BUF->len[0] << 8) + BUF->len[1];
+#if UIP_CONF_IPV6
+    uip_len += 40; /* The length reported in the IPv6 header is the
+		      length of the payload that follows the
+		      header. However, uIP uses the uip_len variable
+		      for holding the size of the entire packet,
+		      including the IP header. For IPv4 this is not a
+		      problem as the length field in the IPv4 header
+		      contains the length of the entire packet. But
+		      for IPv6 we need to add the size of the IPv6
+		      header (40 bytes). */
+#endif /* UIP_CONF_IPV6 */
+  } else {
+    UIP_LOG("ip: packet shorter than reported in IP header.");
+    goto drop;
+  }
+
+#if !UIP_CONF_IPV6
+  /* Check the fragment flag. */
+  if((BUF->ipoffset[0] & 0x3f) != 0 ||
+     BUF->ipoffset[1] != 0) {
+#if UIP_REASSEMBLY
+    uip_len = uip_reass();
+    if(uip_len == 0) {
+      goto drop;
+    }
+#else /* UIP_REASSEMBLY */
+    UIP_STAT(++uip_stat.ip.drop);
+    UIP_STAT(++uip_stat.ip.fragerr);
+    UIP_LOG("ip: fragment dropped.");
+    goto drop;
+#endif /* UIP_REASSEMBLY */
+  }
+#endif /* UIP_CONF_IPV6 */
+
+  if(uip_ipaddr_cmp(&uip_hostaddr, &uip_all_zeroes_addr)) {
+    /* If we are configured to use ping IP address configuration and
+       hasn't been assigned an IP address yet, we accept all ICMP
+       packets. */
+#if UIP_PINGADDRCONF && !UIP_CONF_IPV6
+    if(BUF->proto == UIP_PROTO_ICMP) {
+      UIP_LOG("ip: possible ping config packet received.");
+      goto icmp_input;
+    } else {
+      UIP_LOG("ip: packet dropped since no address assigned.");
+      goto drop;
+    }
+#endif /* UIP_PINGADDRCONF */
+
+  } else {
+    /* If IP broadcast support is configured, we check for a broadcast
+       UDP packet, which may be destined to us. */
+#if UIP_BROADCAST
+    DEBUG_PRINTF("UDP IP checksum 0x%04x\n", uip_ipchksum());
+    if(BUF->proto == UIP_PROTO_UDP &&
+       uip_ipaddr_cmp(&BUF->destipaddr, &uip_broadcast_addr)
+       /*&&
+	 uip_ipchksum() == 0xffff*/) {
+      goto udp_input;
+    }
+#endif /* UIP_BROADCAST */
+    
+    /* Check if the packet is destined for our IP address. */
+#if !UIP_CONF_IPV6
+    if(!uip_ipaddr_cmp(&BUF->destipaddr, &uip_hostaddr)) {
+      UIP_STAT(++uip_stat.ip.drop);
+      goto drop;
+    }
+#else /* UIP_CONF_IPV6 */
+    /* For IPv6, packet reception is a little trickier as we need to
+       make sure that we listen to certain multicast addresses (all
+       hosts multicast address, and the solicited-node multicast
+       address) as well. However, we will cheat here and accept all
+       multicast packets that are sent to the ff02::/16 addresses. */
+    if(!uip_ipaddr_cmp(&BUF->destipaddr, &uip_hostaddr) &&
+       BUF->destipaddr.u16[0] != HTONS(0xff02)) {
+      UIP_STAT(++uip_stat.ip.drop);
+      goto drop;
+    }
+#endif /* UIP_CONF_IPV6 */
+  }
+
+#if !UIP_CONF_IPV6
+  if(uip_ipchksum() != 0xffff) { /* Compute and check the IP header
+				    checksum. */
+    UIP_STAT(++uip_stat.ip.drop);
+    UIP_STAT(++uip_stat.ip.chkerr);
+    UIP_LOG("ip: bad checksum.");
+    goto drop;
+  }
+#endif /* UIP_CONF_IPV6 */
+
+  if(BUF->proto == UIP_PROTO_TCP) { /* Check for TCP packet. If so,
+				       proceed with TCP input
+				       processing. */
+    goto tcp_input;
+  }
+
+#if UIP_UDP
+  if(BUF->proto == UIP_PROTO_UDP) {
+    goto udp_input;
+  }
+#endif /* UIP_UDP */
+
+#if !UIP_CONF_IPV6
+  /* ICMPv4 processing code follows. */
+  if(BUF->proto != UIP_PROTO_ICMP) { /* We only allow ICMP packets from
+					here. */
+    UIP_STAT(++uip_stat.ip.drop);
+    UIP_STAT(++uip_stat.ip.protoerr);
+    UIP_LOG("ip: neither tcp nor icmp.");
+    goto drop;
+  }
+
+#if UIP_PINGADDRCONF
+ icmp_input:
+#endif /* UIP_PINGADDRCONF */
+  UIP_STAT(++uip_stat.icmp.recv);
+
+  /* ICMP echo (i.e., ping) processing. This is simple, we only change
+     the ICMP type from ECHO to ECHO_REPLY and adjust the ICMP
+     checksum before we return the packet. */
+  if(ICMPBUF->type != ICMP_ECHO) {
+    UIP_STAT(++uip_stat.icmp.drop);
+    UIP_STAT(++uip_stat.icmp.typeerr);
+    UIP_LOG("icmp: not icmp echo.");
+    goto drop;
+  }
+
+  /* If we are configured to use ping IP address assignment, we use
+     the destination IP address of this ping packet and assign it to
+     ourself. */
+#if UIP_PINGADDRCONF
+  if(uip_ipaddr_cmp(&uip_hostaddr, &uip_all_zeroes_addr)) {
+    uip_hostaddr = BUF->destipaddr;
+  }
+#endif /* UIP_PINGADDRCONF */
+
+  ICMPBUF->type = ICMP_ECHO_REPLY;
+
+  if(ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) {
+    ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;
+  } else {
+    ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);
+  }
+
+  /* Swap IP addresses. */
+  uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);
+  uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
+
+  UIP_STAT(++uip_stat.icmp.sent);
+  BUF->ttl = UIP_TTL;
+  goto ip_send_nolen;
+
+  /* End of IPv4 input header processing code. */
+#else /* !UIP_CONF_IPV6 */
+
+  /* This is IPv6 ICMPv6 processing code. */
+  DEBUG_PRINTF("icmp6_input: length %d\n", uip_len);
+
+  if(BUF->proto != UIP_PROTO_ICMP6) { /* We only allow ICMPv6 packets from
+					 here. */
+    UIP_STAT(++uip_stat.ip.drop);
+    UIP_STAT(++uip_stat.ip.protoerr);
+    UIP_LOG("ip: neither tcp nor icmp6.");
+    goto drop;
+  }
+
+  UIP_STAT(++uip_stat.icmp.recv);
+
+  /* If we get a neighbor solicitation for our address we should send
+     a neighbor advertisement message back. */
+  if(ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION) {
+    if(uip_ipaddr_cmp(&ICMPBUF->icmp6data, &uip_hostaddr)) {
+
+      if(ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS) {
+	/* Save the sender's address in our neighbor list. */
+	uip_neighbor_add(&ICMPBUF->srcipaddr, &(ICMPBUF->options[2]));
+      }
+      
+      /* We should now send a neighbor advertisement back to where the
+	 neighbor solicication came from. */
+      ICMPBUF->type = ICMP6_NEIGHBOR_ADVERTISEMENT;
+      ICMPBUF->flags = ICMP6_FLAG_S; /* Solicited flag. */
+      
+      ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0;
+      
+      uip_ipaddr_copy(&ICMPBUF->destipaddr, &ICMPBUF->srcipaddr);
+      uip_ipaddr_copy(&ICMPBUF->srcipaddr, &uip_hostaddr);
+      ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;
+      ICMPBUF->options[1] = 1;  /* Options length, 1 = 8 bytes. */
+      memcpy(&(ICMPBUF->options[2]), &uip_ethaddr, sizeof(uip_ethaddr));
+      ICMPBUF->icmpchksum = 0;
+      ICMPBUF->icmpchksum = ~uip_icmp6chksum();
+      
+      goto send;
+      
+    }
+    goto drop;
+  } else if(ICMPBUF->type == ICMP6_ECHO) {
+    /* ICMP echo (i.e., ping) processing. This is simple, we only
+       change the ICMP type from ECHO to ECHO_REPLY and update the
+       ICMP checksum before we return the packet. */
+
+    ICMPBUF->type = ICMP6_ECHO_REPLY;
+    
+    uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);
+    uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
+    ICMPBUF->icmpchksum = 0;
+    ICMPBUF->icmpchksum = ~uip_icmp6chksum();
+    
+    UIP_STAT(++uip_stat.icmp.sent);
+    goto send;
+  } else {
+    DEBUG_PRINTF("Unknown icmp6 message type %d\n", ICMPBUF->type);
+    UIP_STAT(++uip_stat.icmp.drop);
+    UIP_STAT(++uip_stat.icmp.typeerr);
+    UIP_LOG("icmp: unknown ICMP message.");
+    goto drop;
+  }
+
+  /* End of IPv6 ICMP processing. */
+  
+#endif /* !UIP_CONF_IPV6 */
+
+#if UIP_UDP
+  /* UDP input processing. */
+ udp_input:
+  /* UDP processing is really just a hack. We don't do anything to the
+     UDP/IP headers, but let the UDP application do all the hard
+     work. If the application sets uip_slen, it has a packet to
+     send. */
+#if UIP_UDP_CHECKSUMS
+  uip_len = uip_len - UIP_IPUDPH_LEN;
+  uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+  if(UDPBUF->udpchksum != 0 && uip_udpchksum() != 0xffff) {
+    UIP_STAT(++uip_stat.udp.drop);
+    UIP_STAT(++uip_stat.udp.chkerr);
+    UIP_LOG("udp: bad checksum.");
+    goto drop;
+  }
+#else /* UIP_UDP_CHECKSUMS */
+  uip_len = uip_len - UIP_IPUDPH_LEN;
+#endif /* UIP_UDP_CHECKSUMS */
+
+  /* Demultiplex this UDP packet between the UDP "connections". */
+  for(uip_udp_conn = &uip_udp_conns[0];
+      uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS];
+      ++uip_udp_conn) {
+    /* If the local UDP port is non-zero, the connection is considered
+       to be used. If so, the local port number is checked against the
+       destination port number in the received packet. If the two port
+       numbers match, the remote port number is checked if the
+       connection is bound to a remote port. Finally, if the
+       connection is bound to a remote IP address, the source IP
+       address of the packet is checked. */
+    if(uip_udp_conn->lport != 0 &&
+       UDPBUF->destport == uip_udp_conn->lport &&
+       (uip_udp_conn->rport == 0 ||
+        UDPBUF->srcport == uip_udp_conn->rport) &&
+       (uip_ipaddr_cmp(&uip_udp_conn->ripaddr, &uip_all_zeroes_addr) ||
+	uip_ipaddr_cmp(&uip_udp_conn->ripaddr, &uip_broadcast_addr) ||
+	uip_ipaddr_cmp(&BUF->srcipaddr, &uip_udp_conn->ripaddr))) {
+      goto udp_found;
+    }
+  }
+  UIP_LOG("udp: no matching connection found");
+#if UIP_CONF_ICMP_DEST_UNREACH && !UIP_CONF_IPV6
+  /* Copy fields from packet header into payload of this ICMP packet. */
+  memcpy(&(ICMPBUF->payload[0]), ICMPBUF, UIP_IPH_LEN + 8);
+
+  /* Set the ICMP type and code. */
+  ICMPBUF->type = ICMP_DEST_UNREACHABLE;
+  ICMPBUF->icode = ICMP_PORT_UNREACHABLE;
+
+  /* Calculate the ICMP checksum. */
+  ICMPBUF->icmpchksum = 0;
+  ICMPBUF->icmpchksum = ~uip_chksum((u16_t *)&(ICMPBUF->type), 36);
+
+  /* Set the IP destination address to be the source address of the
+     original packet. */
+  uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);
+
+  /* Set our IP address as the source address. */
+  uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
+
+  /* The size of the ICMP destination unreachable packet is 36 + the
+     size of the IP header (20) = 56. */
+  uip_len = 36 + UIP_IPH_LEN;
+  ICMPBUF->len[0] = 0;
+  ICMPBUF->len[1] = (u8_t)uip_len;
+  ICMPBUF->ttl = UIP_TTL;
+  ICMPBUF->proto = UIP_PROTO_ICMP;
+
+  goto ip_send_nolen;
+#else /* UIP_CONF_ICMP_DEST_UNREACH */
+  goto drop;
+#endif /* UIP_CONF_ICMP_DEST_UNREACH */
+  
+ udp_found:
+  uip_conn = NULL;
+  uip_flags = UIP_NEWDATA;
+  uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+  uip_slen = 0;
+  UIP_UDP_APPCALL();
+
+ udp_send:
+  if(uip_slen == 0) {
+    goto drop;
+  }
+  uip_len = uip_slen + UIP_IPUDPH_LEN;
+
+#if UIP_CONF_IPV6
+  /* For IPv6, the IP length field does not include the IPv6 IP header
+     length. */
+  BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
+  BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
+#else /* UIP_CONF_IPV6 */
+  BUF->len[0] = (uip_len >> 8);
+  BUF->len[1] = (uip_len & 0xff);
+#endif /* UIP_CONF_IPV6 */
+
+  BUF->ttl = uip_udp_conn->ttl;
+  BUF->proto = UIP_PROTO_UDP;
+
+  UDPBUF->udplen = HTONS(uip_slen + UIP_UDPH_LEN);
+  UDPBUF->udpchksum = 0;
+
+  BUF->srcport  = uip_udp_conn->lport;
+  BUF->destport = uip_udp_conn->rport;
+
+  uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
+  uip_ipaddr_copy(&BUF->destipaddr, &uip_udp_conn->ripaddr);
+   
+  uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPTCPH_LEN];
+
+#if UIP_UDP_CHECKSUMS
+  /* Calculate UDP checksum. */
+  UDPBUF->udpchksum = ~(uip_udpchksum());
+  if(UDPBUF->udpchksum == 0) {
+    UDPBUF->udpchksum = 0xffff;
+  }
+#endif /* UIP_UDP_CHECKSUMS */
+  
+  goto ip_send_nolen;
+#endif /* UIP_UDP */
+  
+  /* TCP input processing. */
+ tcp_input:
+  UIP_STAT(++uip_stat.tcp.recv);
+
+  /* Start of TCP input header processing code. */
+  
+  if(uip_tcpchksum() != 0xffff) {   /* Compute and check the TCP
+				       checksum. */
+    UIP_STAT(++uip_stat.tcp.drop);
+    UIP_STAT(++uip_stat.tcp.chkerr);
+    UIP_LOG("tcp: bad checksum.");
+    goto drop;
+  }
+  
+  /* Demultiplex this segment. */
+  /* First check any active connections. */
+  for(uip_connr = &uip_conns[0]; uip_connr <= &uip_conns[UIP_CONNS - 1];
+      ++uip_connr) {
+    if(uip_connr->tcpstateflags != UIP_CLOSED &&
+       BUF->destport == uip_connr->lport &&
+       BUF->srcport == uip_connr->rport &&
+       uip_ipaddr_cmp(&BUF->srcipaddr, &uip_connr->ripaddr)) {
+      goto found;
+    }
+  }
+
+  /* If we didn't find and active connection that expected the packet,
+     either this packet is an old duplicate, or this is a SYN packet
+     destined for a connection in LISTEN. If the SYN flag isn't set,
+     it is an old packet and we send a RST. */
+  if((BUF->flags & TCP_CTL) != TCP_SYN) {
+    goto reset;
+  }
+  
+  tmp16 = BUF->destport;
+  /* Next, check listening connections. */
+  for(c = 0; c < UIP_LISTENPORTS; ++c) {
+    if(tmp16 == uip_listenports[c]) {
+      goto found_listen;
+    }
+  }
+  
+  /* No matching connection found, so we send a RST packet. */
+  UIP_STAT(++uip_stat.tcp.synrst);
+
+ reset:
+  /* We do not send resets in response to resets. */
+  if(BUF->flags & TCP_RST) {
+    goto drop;
+  }
+
+  UIP_STAT(++uip_stat.tcp.rst);
+  
+  BUF->flags = TCP_RST | TCP_ACK;
+  uip_len = UIP_IPTCPH_LEN;
+  BUF->tcpoffset = 5 << 4;
+
+  /* Flip the seqno and ackno fields in the TCP header. */
+  c = BUF->seqno[3];
+  BUF->seqno[3] = BUF->ackno[3];
+  BUF->ackno[3] = c;
+  
+  c = BUF->seqno[2];
+  BUF->seqno[2] = BUF->ackno[2];
+  BUF->ackno[2] = c;
+  
+  c = BUF->seqno[1];
+  BUF->seqno[1] = BUF->ackno[1];
+  BUF->ackno[1] = c;
+  
+  c = BUF->seqno[0];
+  BUF->seqno[0] = BUF->ackno[0];
+  BUF->ackno[0] = c;
+
+  /* We also have to increase the sequence number we are
+     acknowledging. If the least significant byte overflowed, we need
+     to propagate the carry to the other bytes as well. */
+  if(++BUF->ackno[3] == 0) {
+    if(++BUF->ackno[2] == 0) {
+      if(++BUF->ackno[1] == 0) {
+	++BUF->ackno[0];
+      }
+    }
+  }
+ 
+  /* Swap port numbers. */
+  tmp16 = BUF->srcport;
+  BUF->srcport = BUF->destport;
+  BUF->destport = tmp16;
+  
+  /* Swap IP addresses. */
+  uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);
+  uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
+  
+  /* And send out the RST packet! */
+  goto tcp_send_noconn;
+
+  /* This label will be jumped to if we matched the incoming packet
+     with a connection in LISTEN. In that case, we should create a new
+     connection and send a SYNACK in return. */
+ found_listen:
+  /* First we check if there are any connections avaliable. Unused
+     connections are kept in the same table as used connections, but
+     unused ones have the tcpstate set to CLOSED. Also, connections in
+     TIME_WAIT are kept track of and we'll use the oldest one if no
+     CLOSED connections are found. Thanks to Eddie C. Dost for a very
+     nice algorithm for the TIME_WAIT search. */
+  uip_connr = 0;
+  for(c = 0; c < UIP_CONNS; ++c) {
+    if(uip_conns[c].tcpstateflags == UIP_CLOSED) {
+      uip_connr = &uip_conns[c];
+      break;
+    }
+    if(uip_conns[c].tcpstateflags == UIP_TIME_WAIT) {
+      if(uip_connr == 0 ||
+	 uip_conns[c].timer > uip_connr->timer) {
+	uip_connr = &uip_conns[c];
+      }
+    }
+  }
+
+  if(uip_connr == 0) {
+    /* All connections are used already, we drop packet and hope that
+       the remote end will retransmit the packet at a time when we
+       have more spare connections. */
+    UIP_STAT(++uip_stat.tcp.syndrop);
+    UIP_LOG("tcp: found no unused connections.");
+    goto drop;
+  }
+  uip_conn = uip_connr;
+  
+  /* Fill in the necessary fields for the new connection. */
+  uip_connr->rto = uip_connr->timer = UIP_RTO;
+  uip_connr->sa = 0;
+  uip_connr->sv = 4;
+  uip_connr->nrtx = 0;
+  uip_connr->lport = BUF->destport;
+  uip_connr->rport = BUF->srcport;
+  uip_ipaddr_copy(&uip_connr->ripaddr, &BUF->srcipaddr);
+  uip_connr->tcpstateflags = UIP_SYN_RCVD;
+
+  uip_connr->snd_nxt[0] = iss[0];
+  uip_connr->snd_nxt[1] = iss[1];
+  uip_connr->snd_nxt[2] = iss[2];
+  uip_connr->snd_nxt[3] = iss[3];
+  uip_connr->len = 1;
+
+  /* rcv_nxt should be the seqno from the incoming packet + 1. */
+  uip_connr->rcv_nxt[3] = BUF->seqno[3];
+  uip_connr->rcv_nxt[2] = BUF->seqno[2];
+  uip_connr->rcv_nxt[1] = BUF->seqno[1];
+  uip_connr->rcv_nxt[0] = BUF->seqno[0];
+  uip_add_rcv_nxt(1);
+
+  /* Parse the TCP MSS option, if present. */
+  if((BUF->tcpoffset & 0xf0) > 0x50) {
+    for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
+      opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];
+      if(opt == TCP_OPT_END) {
+	/* End of options. */
+	break;
+      } else if(opt == TCP_OPT_NOOP) {
+	++c;
+	/* NOP option. */
+      } else if(opt == TCP_OPT_MSS &&
+		uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
+	/* An MSS option with the right option length. */
+	tmp16 = ((u16_t)uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
+	  (u16_t)uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + c];
+	uip_connr->initialmss = uip_connr->mss =
+	  tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
+	
+	/* And we are done processing options. */
+	break;
+      } else {
+	/* All other options have a length field, so that we easily
+	   can skip past them. */
+	if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
+	  /* If the length field is zero, the options are malformed
+	     and we don't process them further. */
+	  break;
+	}
+	c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
+      }
+    }
+  }
+  
+  /* Our response will be a SYNACK. */
+#if UIP_ACTIVE_OPEN
+ tcp_send_synack:
+  BUF->flags = TCP_ACK;
+  
+ tcp_send_syn:
+  BUF->flags |= TCP_SYN;
+#else /* UIP_ACTIVE_OPEN */
+ tcp_send_synack:
+  BUF->flags = TCP_SYN | TCP_ACK;
+#endif /* UIP_ACTIVE_OPEN */
+  
+  /* We send out the TCP Maximum Segment Size option with our
+     SYNACK. */
+  BUF->optdata[0] = TCP_OPT_MSS;
+  BUF->optdata[1] = TCP_OPT_MSS_LEN;
+  BUF->optdata[2] = (UIP_TCP_MSS) / 256;
+  BUF->optdata[3] = (UIP_TCP_MSS) & 255;
+  uip_len = UIP_IPTCPH_LEN + TCP_OPT_MSS_LEN;
+  BUF->tcpoffset = ((UIP_TCPH_LEN + TCP_OPT_MSS_LEN) / 4) << 4;
+  goto tcp_send;
+
+  /* This label will be jumped to if we found an active connection. */
+ found:
+  uip_conn = uip_connr;
+  uip_flags = 0;
+  /* We do a very naive form of TCP reset processing; we just accept
+     any RST and kill our connection. We should in fact check if the
+     sequence number of this reset is wihtin our advertised window
+     before we accept the reset. */
+  if(BUF->flags & TCP_RST) {
+    uip_connr->tcpstateflags = UIP_CLOSED;
+    UIP_LOG("tcp: got reset, aborting connection.");
+    uip_flags = UIP_ABORT;
+    UIP_APPCALL();
+    goto drop;
+  }
+  /* Calculate the length of the data, if the application has sent
+     any data to us. */
+  c = (BUF->tcpoffset >> 4) << 2;
+  /* uip_len will contain the length of the actual TCP data. This is
+     calculated by subtracing the length of the TCP header (in
+     c) and the length of the IP header (20 bytes). */
+  uip_len = uip_len - c - UIP_IPH_LEN;
+
+  /* First, check if the sequence number of the incoming packet is
+     what we're expecting next. If not, we send out an ACK with the
+     correct numbers in. */
+  if(!(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) &&
+       ((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)))) {
+    if((uip_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0)) &&
+       (BUF->seqno[0] != uip_connr->rcv_nxt[0] ||
+	BUF->seqno[1] != uip_connr->rcv_nxt[1] ||
+	BUF->seqno[2] != uip_connr->rcv_nxt[2] ||
+	BUF->seqno[3] != uip_connr->rcv_nxt[3])) {
+      goto tcp_send_ack;
+    }
+  }
+
+  /* Next, check if the incoming segment acknowledges any outstanding
+     data. If so, we update the sequence number, reset the length of
+     the outstanding data, calculate RTT estimations, and reset the
+     retransmission timer. */
+  if((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) {
+    uip_add32(uip_connr->snd_nxt, uip_connr->len);
+
+    if(BUF->ackno[0] == uip_acc32[0] &&
+       BUF->ackno[1] == uip_acc32[1] &&
+       BUF->ackno[2] == uip_acc32[2] &&
+       BUF->ackno[3] == uip_acc32[3]) {
+      /* Update sequence number. */
+      uip_connr->snd_nxt[0] = uip_acc32[0];
+      uip_connr->snd_nxt[1] = uip_acc32[1];
+      uip_connr->snd_nxt[2] = uip_acc32[2];
+      uip_connr->snd_nxt[3] = uip_acc32[3];
+	
+      /* Do RTT estimation, unless we have done retransmissions. */
+      if(uip_connr->nrtx == 0) {
+	signed char m;
+	m = uip_connr->rto - uip_connr->timer;
+	/* This is taken directly from VJs original code in his paper */
+	m = m - (uip_connr->sa >> 3);
+	uip_connr->sa += m;
+	if(m < 0) {
+	  m = -m;
+	}
+	m = m - (uip_connr->sv >> 2);
+	uip_connr->sv += m;
+	uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;
+
+      }
+      /* Set the acknowledged flag. */
+      uip_flags = UIP_ACKDATA;
+      /* Reset the retransmission timer. */
+      uip_connr->timer = uip_connr->rto;
+
+      /* Reset length of outstanding data. */
+      uip_connr->len = 0;
+    }
+    
+  }
+
+  /* Do different things depending on in what state the connection is. */
+  switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
+    /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not
+	implemented, since we force the application to close when the
+	peer sends a FIN (hence the application goes directly from
+	ESTABLISHED to LAST_ACK). */
+  case UIP_SYN_RCVD:
+    /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and
+       we are waiting for an ACK that acknowledges the data we sent
+       out the last time. Therefore, we want to have the UIP_ACKDATA
+       flag set. If so, we enter the ESTABLISHED state. */
+    if(uip_flags & UIP_ACKDATA) {
+      uip_connr->tcpstateflags = UIP_ESTABLISHED;
+      uip_flags = UIP_CONNECTED;
+      uip_connr->len = 0;
+      if(uip_len > 0) {
+        uip_flags |= UIP_NEWDATA;
+        uip_add_rcv_nxt(uip_len);
+      }
+      uip_slen = 0;
+      UIP_APPCALL();
+      goto appsend;
+    }
+    goto drop;
+#if UIP_ACTIVE_OPEN
+  case UIP_SYN_SENT:
+    /* In SYN_SENT, we wait for a SYNACK that is sent in response to
+       our SYN. The rcv_nxt is set to sequence number in the SYNACK
+       plus one, and we send an ACK. We move into the ESTABLISHED
+       state. */
+    if((uip_flags & UIP_ACKDATA) &&
+       (BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)) {
+
+      /* Parse the TCP MSS option, if present. */
+      if((BUF->tcpoffset & 0xf0) > 0x50) {
+	for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
+	  opt = uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + c];
+	  if(opt == TCP_OPT_END) {
+	    /* End of options. */
+	    break;
+	  } else if(opt == TCP_OPT_NOOP) {
+	    ++c;
+	    /* NOP option. */
+	  } else if(opt == TCP_OPT_MSS &&
+		    uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
+	    /* An MSS option with the right option length. */
+	    tmp16 = (uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
+	      uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];
+	    uip_connr->initialmss =
+	      uip_connr->mss = tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
+
+	    /* And we are done processing options. */
+	    break;
+	  } else {
+	    /* All other options have a length field, so that we easily
+	       can skip past them. */
+	    if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
+	      /* If the length field is zero, the options are malformed
+		 and we don't process them further. */
+	      break;
+	    }
+	    c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
+	  }
+	}
+      }
+      uip_connr->tcpstateflags = UIP_ESTABLISHED;
+      uip_connr->rcv_nxt[0] = BUF->seqno[0];
+      uip_connr->rcv_nxt[1] = BUF->seqno[1];
+      uip_connr->rcv_nxt[2] = BUF->seqno[2];
+      uip_connr->rcv_nxt[3] = BUF->seqno[3];
+      uip_add_rcv_nxt(1);
+      uip_flags = UIP_CONNECTED | UIP_NEWDATA;
+      uip_connr->len = 0;
+      uip_len = 0;
+      uip_slen = 0;
+      UIP_APPCALL();
+      goto appsend;
+    }
+    /* Inform the application that the connection failed */
+    uip_flags = UIP_ABORT;
+    UIP_APPCALL();
+    /* The connection is closed after we send the RST */
+    uip_conn->tcpstateflags = UIP_CLOSED;
+    goto reset;
+#endif /* UIP_ACTIVE_OPEN */
+    
+  case UIP_ESTABLISHED:
+    /* In the ESTABLISHED state, we call upon the application to feed
+    data into the uip_buf. If the UIP_ACKDATA flag is set, the
+    application should put new data into the buffer, otherwise we are
+    retransmitting an old segment, and the application should put that
+    data into the buffer.
+
+    If the incoming packet is a FIN, we should close the connection on
+    this side as well, and we send out a FIN and enter the LAST_ACK
+    state. We require that there is no outstanding data; otherwise the
+    sequence numbers will be screwed up. */
+
+    if(BUF->flags & TCP_FIN && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
+      if(uip_outstanding(uip_connr)) {
+	goto drop;
+      }
+      uip_add_rcv_nxt(1 + uip_len);
+      uip_flags |= UIP_CLOSE;
+      if(uip_len > 0) {
+	uip_flags |= UIP_NEWDATA;
+      }
+      UIP_APPCALL();
+      uip_connr->len = 1;
+      uip_connr->tcpstateflags = UIP_LAST_ACK;
+      uip_connr->nrtx = 0;
+    tcp_send_finack:
+      BUF->flags = TCP_FIN | TCP_ACK;
+      goto tcp_send_nodata;
+    }
+
+    /* Check the URG flag. If this is set, the segment carries urgent
+       data that we must pass to the application. */
+    if((BUF->flags & TCP_URG) != 0) {
+#if UIP_URGDATA > 0
+      uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];
+      if(uip_urglen > uip_len) {
+	/* There is more urgent data in the next segment to come. */
+	uip_urglen = uip_len;
+      }
+      uip_add_rcv_nxt(uip_urglen);
+      uip_len -= uip_urglen;
+      uip_urgdata = uip_appdata;
+      uip_appdata += uip_urglen;
+    } else {
+      uip_urglen = 0;
+#else /* UIP_URGDATA > 0 */
+      uip_appdata = ((char *)uip_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]);
+      uip_len -= (BUF->urgp[0] << 8) | BUF->urgp[1];
+#endif /* UIP_URGDATA > 0 */
+    }
+
+    /* If uip_len > 0 we have TCP data in the packet, and we flag this
+       by setting the UIP_NEWDATA flag and update the sequence number
+       we acknowledge. If the application has stopped the dataflow
+       using uip_stop(), we must not accept any data packets from the
+       remote host. */
+    if(uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
+      uip_flags |= UIP_NEWDATA;
+      uip_add_rcv_nxt(uip_len);
+    }
+
+    /* Check if the available buffer space advertised by the other end
+       is smaller than the initial MSS for this connection. If so, we
+       set the current MSS to the window size to ensure that the
+       application does not send more data than the other end can
+       handle.
+
+       If the remote host advertises a zero window, we set the MSS to
+       the initial MSS so that the application will send an entire MSS
+       of data. This data will not be acknowledged by the receiver,
+       and the application will retransmit it. This is called the
+       "persistent timer" and uses the retransmission mechanim.
+    */
+    tmp16 = ((u16_t)BUF->wnd[0] << 8) + (u16_t)BUF->wnd[1];
+    if(tmp16 > uip_connr->initialmss ||
+       tmp16 == 0) {
+      tmp16 = uip_connr->initialmss;
+    }
+    uip_connr->mss = tmp16;
+
+    /* If this packet constitutes an ACK for outstanding data (flagged
+       by the UIP_ACKDATA flag, we should call the application since it
+       might want to send more data. If the incoming packet had data
+       from the peer (as flagged by the UIP_NEWDATA flag), the
+       application must also be notified.
+
+       When the application is called, the global variable uip_len
+       contains the length of the incoming data. The application can
+       access the incoming data through the global pointer
+       uip_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN
+       bytes into the uip_buf array.
+
+       If the application wishes to send any data, this data should be
+       put into the uip_appdata and the length of the data should be
+       put into uip_len. If the application don't have any data to
+       send, uip_len must be set to 0. */
+    if(uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) {
+      uip_slen = 0;
+      UIP_APPCALL();
+
+    appsend:
+      
+      if(uip_flags & UIP_ABORT) {
+	uip_slen = 0;
+	uip_connr->tcpstateflags = UIP_CLOSED;
+	BUF->flags = TCP_RST | TCP_ACK;
+	goto tcp_send_nodata;
+      }
+
+      if(uip_flags & UIP_CLOSE) {
+	uip_slen = 0;
+	uip_connr->len = 1;
+	uip_connr->tcpstateflags = UIP_FIN_WAIT_1;
+	uip_connr->nrtx = 0;
+	BUF->flags = TCP_FIN | TCP_ACK;
+	goto tcp_send_nodata;
+      }
+
+      /* If uip_slen > 0, the application has data to be sent. */
+      if(uip_slen > 0) {
+
+	/* If the connection has acknowledged data, the contents of
+	   the ->len variable should be discarded. */
+	if((uip_flags & UIP_ACKDATA) != 0) {
+	  uip_connr->len = 0;
+	}
+
+	/* If the ->len variable is non-zero the connection has
+	   already data in transit and cannot send anymore right
+	   now. */
+	if(uip_connr->len == 0) {
+
+	  /* The application cannot send more than what is allowed by
+	     the mss (the minumum of the MSS and the available
+	     window). */
+	  if(uip_slen > uip_connr->mss) {
+	    uip_slen = uip_connr->mss;
+	  }
+
+	  /* Remember how much data we send out now so that we know
+	     when everything has been acknowledged. */
+	  uip_connr->len = uip_slen;
+	} else {
+
+	  /* If the application already had unacknowledged data, we
+	     make sure that the application does not send (i.e.,
+	     retransmit) out more than it previously sent out. */
+	  uip_slen = uip_connr->len;
+	}
+      }
+      uip_connr->nrtx = 0;
+    apprexmit:
+      uip_appdata = uip_sappdata;
+      
+      /* If the application has data to be sent, or if the incoming
+         packet had new data in it, we must send out a packet. */
+      if(uip_slen > 0 && uip_connr->len > 0) {
+	/* Add the length of the IP and TCP headers. */
+	uip_len = uip_connr->len + UIP_TCPIP_HLEN;
+	/* We always set the ACK flag in response packets. */
+	BUF->flags = TCP_ACK | TCP_PSH;
+	/* Send the packet. */
+	goto tcp_send_noopts;
+      }
+      /* If there is no data to send, just send out a pure ACK if
+	 there is newdata. */
+      if(uip_flags & UIP_NEWDATA) {
+	uip_len = UIP_TCPIP_HLEN;
+	BUF->flags = TCP_ACK;
+	goto tcp_send_noopts;
+      }
+    }
+    goto drop;
+  case UIP_LAST_ACK:
+    /* We can close this connection if the peer has acknowledged our
+       FIN. This is indicated by the UIP_ACKDATA flag. */
+    if(uip_flags & UIP_ACKDATA) {
+      uip_connr->tcpstateflags = UIP_CLOSED;
+      uip_flags = UIP_CLOSE;
+      UIP_APPCALL();
+    }
+    break;
+    
+  case UIP_FIN_WAIT_1:
+    /* The application has closed the connection, but the remote host
+       hasn't closed its end yet. Thus we do nothing but wait for a
+       FIN from the other side. */
+    if(uip_len > 0) {
+      uip_add_rcv_nxt(uip_len);
+    }
+    if(BUF->flags & TCP_FIN) {
+      if(uip_flags & UIP_ACKDATA) {
+	uip_connr->tcpstateflags = UIP_TIME_WAIT;
+	uip_connr->timer = 0;
+	uip_connr->len = 0;
+      } else {
+	uip_connr->tcpstateflags = UIP_CLOSING;
+      }
+      uip_add_rcv_nxt(1);
+      uip_flags = UIP_CLOSE;
+      UIP_APPCALL();
+      goto tcp_send_ack;
+    } else if(uip_flags & UIP_ACKDATA) {
+      uip_connr->tcpstateflags = UIP_FIN_WAIT_2;
+      uip_connr->len = 0;
+      goto drop;
+    }
+    if(uip_len > 0) {
+      goto tcp_send_ack;
+    }
+    goto drop;
+      
+  case UIP_FIN_WAIT_2:
+    if(uip_len > 0) {
+      uip_add_rcv_nxt(uip_len);
+    }
+    if(BUF->flags & TCP_FIN) {
+      uip_connr->tcpstateflags = UIP_TIME_WAIT;
+      uip_connr->timer = 0;
+      uip_add_rcv_nxt(1);
+      uip_flags = UIP_CLOSE;
+      UIP_APPCALL();
+      goto tcp_send_ack;
+    }
+    if(uip_len > 0) {
+      goto tcp_send_ack;
+    }
+    goto drop;
+
+  case UIP_TIME_WAIT:
+    goto tcp_send_ack;
+    
+  case UIP_CLOSING:
+    if(uip_flags & UIP_ACKDATA) {
+      uip_connr->tcpstateflags = UIP_TIME_WAIT;
+      uip_connr->timer = 0;
+    }
+  }
+  goto drop;
+  
+  /* We jump here when we are ready to send the packet, and just want
+     to set the appropriate TCP sequence numbers in the TCP header. */
+ tcp_send_ack:
+  BUF->flags = TCP_ACK;
+
+ tcp_send_nodata:
+  uip_len = UIP_IPTCPH_LEN;
+
+ tcp_send_noopts:
+  BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4;
+
+  /* We're done with the input processing. We are now ready to send a
+     reply. Our job is to fill in all the fields of the TCP and IP
+     headers before calculating the checksum and finally send the
+     packet. */
+ tcp_send:
+  BUF->ackno[0] = uip_connr->rcv_nxt[0];
+  BUF->ackno[1] = uip_connr->rcv_nxt[1];
+  BUF->ackno[2] = uip_connr->rcv_nxt[2];
+  BUF->ackno[3] = uip_connr->rcv_nxt[3];
+  
+  BUF->seqno[0] = uip_connr->snd_nxt[0];
+  BUF->seqno[1] = uip_connr->snd_nxt[1];
+  BUF->seqno[2] = uip_connr->snd_nxt[2];
+  BUF->seqno[3] = uip_connr->snd_nxt[3];
+
+  BUF->proto = UIP_PROTO_TCP;
+  
+  BUF->srcport  = uip_connr->lport;
+  BUF->destport = uip_connr->rport;
+
+  uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
+  uip_ipaddr_copy(&BUF->destipaddr, &uip_connr->ripaddr);
+
+  if(uip_connr->tcpstateflags & UIP_STOPPED) {
+    /* If the connection has issued uip_stop(), we advertise a zero
+       window so that the remote host will stop sending data. */
+    BUF->wnd[0] = BUF->wnd[1] = 0;
+  } else {
+    BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);
+    BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff);
+  }
+
+ tcp_send_noconn:
+  BUF->ttl = UIP_TTL;
+#if UIP_CONF_IPV6
+  /* For IPv6, the IP length field does not include the IPv6 IP header
+     length. */
+  BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
+  BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
+#else /* UIP_CONF_IPV6 */
+  BUF->len[0] = (uip_len >> 8);
+  BUF->len[1] = (uip_len & 0xff);
+#endif /* UIP_CONF_IPV6 */
+
+  BUF->urgp[0] = BUF->urgp[1] = 0;
+  
+  /* Calculate TCP checksum. */
+  BUF->tcpchksum = 0;
+  BUF->tcpchksum = ~(uip_tcpchksum());
+
+ ip_send_nolen:
+#if UIP_CONF_IPV6
+  BUF->vtc = 0x60;
+  BUF->tcflow = 0x00;
+  BUF->flow = 0x00;
+#else /* UIP_CONF_IPV6 */
+  BUF->vhl = 0x45;
+  BUF->tos = 0;
+  BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
+  ++ipid;
+  BUF->ipid[0] = ipid >> 8;
+  BUF->ipid[1] = ipid & 0xff;
+  /* Calculate IP checksum. */
+  BUF->ipchksum = 0;
+  BUF->ipchksum = ~(uip_ipchksum());
+  DEBUG_PRINTF("uip ip_send_nolen: chkecum 0x%04x\n", uip_ipchksum());
+#endif /* UIP_CONF_IPV6 */   
+  UIP_STAT(++uip_stat.tcp.sent);
+#if UIP_CONF_IPV6
+ send:
+#endif /* UIP_CONF_IPV6 */
+  DEBUG_PRINTF("Sending packet with length %d (%d)\n", uip_len,
+	       (BUF->len[0] << 8) | BUF->len[1]);
+  
+  UIP_STAT(++uip_stat.ip.sent);
+  /* Return and let the caller do the actual transmission. */
+  uip_flags = 0;
+  return;
+
+ drop:
+  uip_len = 0;
+  uip_flags = 0;
+  return;
+}
+/*---------------------------------------------------------------------------*/
+u16_t
+htons(u16_t val)
+{
+  return HTONS(val);
+}
+
+u32_t
+htonl(u32_t val)
+{
+  return HTONL(val);
+}
+/*---------------------------------------------------------------------------*/
+void
+uip_send(const void *data, int len)
+{
+  int copylen;
+#define MIN(a,b) ((a) < (b)? (a): (b))
+  copylen = MIN(len, UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN -
+		(int)((char *)uip_sappdata - (char *)&uip_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN]));
+  if(copylen > 0) {
+    uip_slen = copylen;
+    if(data != uip_sappdata) {
+      memcpy(uip_sappdata, (data), uip_slen);
+    }
+  }
+}
+/*---------------------------------------------------------------------------*/
+/** @} */
+#endif /* UIP_CONF_IPV6 */
diff --git a/Projects/Webserver/Lib/uip/uip.h b/Projects/Webserver/Lib/uip/uip.h
index 3e8504c49..a10699dc1 100644
--- a/Projects/Webserver/Lib/uip/uip.h
+++ b/Projects/Webserver/Lib/uip/uip.h
@@ -1,2129 +1,2129 @@
-

-/**

- * \addtogroup uip

- * @{

- */

-

-/**

- * \file

- * Header file for the uIP TCP/IP stack.

- * \author  Adam Dunkels <adam@dunkels.com>

- * \author  Julien Abeille <jabeille@cisco.com> (IPv6 related code)

- * \author  Mathilde Durvy <mdurvy@cisco.com> (IPv6 related code)

- *

- * The uIP TCP/IP stack header file contains definitions for a number

- * of C macros that are used by uIP programs as well as internal uIP

- * structures, TCP/IP header structures and function declarations.

- *

- */

-

-/*

- * Copyright (c) 2001-2003, Adam Dunkels.

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- * 1. Redistributions of source code must retain the above copyright

- *    notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- *    notice, this list of conditions and the following disclaimer in the

- *    documentation and/or other materials provided with the distribution.

- * 3. The name of the author may not be used to endorse or promote

- *    products derived from this software without specific prior

- *    written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS

- * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE

- * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- *

- * This file is part of the uIP TCP/IP stack.

- *

- * $Id: uip.h,v 1.24 2009/04/06 13:18:50 nvt-se Exp $

- *

- */

-

-#ifndef __UIP_H__

-#define __UIP_H__

-

-#include "uipopt.h"

-

-/**

- * Representation of an IP address.

- *

- */

-#if UIP_CONF_IPV6

-typedef union uip_ip6addr_t {

-  u8_t  u8[16];			/* Initializer, must come first!!! */

-  u16_t u16[8];

-} uip_ip6addr_t;

-

-typedef uip_ip6addr_t uip_ipaddr_t;

-#else /* UIP_CONF_IPV6 */

-typedef union uip_ip4addr_t {

-  u8_t  u8[4];			/* Initializer, must come first!!! */

-  u16_t u16[2];

-#if 0

-  u32_t u32;

-#endif

-} uip_ip4addr_t;

-typedef uip_ip4addr_t uip_ipaddr_t;

-#endif /* UIP_CONF_IPV6 */

-

-

-/*---------------------------------------------------------------------------*/

-

-/** \brief 16 bit 802.15.4 address */

-struct uip_802154_shortaddr {

-  u8_t addr[2];

-};

-/** \brief 64 bit 802.15.4 address */

-struct uip_802154_longaddr {

-  u8_t addr[8];

-};

-

-/** \brief 802.11 address */

-struct uip_80211_addr {

-  u8_t addr[6];

-};

-

-/** \brief 802.3 address */

-struct uip_eth_addr {

-  u8_t addr[6];

-};

-

-#if UIP_CONF_LL_802154

-/** \brief 802.15.4 address */

-typedef struct uip_802154_longaddr uip_lladdr_t;

-#define UIP_802154_SHORTADDR_LEN 2

-#define UIP_802154_LONGADDR_LEN  8

-#define UIP_LLADDR_LEN UIP_802154_LONGADDR_LEN

-#else /*UIP_CONF_LL_802154*/

-#if UIP_CONF_LL_80211

-/** \brief 802.11 address */

-typedef struct uip_80211_addr uip_lladdr_t;

-#define UIP_LLADDR_LEN 6

-#else /*UIP_CONF_LL_80211*/

-/** \brief Ethernet address */

-typedef struct uip_eth_addr uip_lladdr_t;

-#define UIP_LLADDR_LEN 6

-#endif /*UIP_CONF_LL_80211*/

-#endif /*UIP_CONF_LL_802154*/

-

-/*---------------------------------------------------------------------------*/

-/* First, the functions that should be called from the

- * system. Initialization, the periodic timer, and incoming packets are

- * handled by the following three functions.

- */

-/**

- * \defgroup uipconffunc uIP configuration functions

- * @{

- *

- * The uIP configuration functions are used for setting run-time

- * parameters in uIP such as IP addresses.

- */

-

-/**

- * Set the IP address of this host.

- *

- * The IP address is represented as a 4-byte array where the first

- * octet of the IP address is put in the first member of the 4-byte

- * array.

- *

- * Example:

- \code

-

- uip_ipaddr_t addr;

-

- uip_ipaddr(&addr, 192,168,1,2);

- uip_sethostaddr(&addr);

- 

- \endcode

- * \param addr A pointer to an IP address of type uip_ipaddr_t;

- *

- * \sa uip_ipaddr()

- *

- * \hideinitializer

- */

-#define uip_sethostaddr(addr) uip_ipaddr_copy(&uip_hostaddr, (addr))

-

-/**

- * Get the IP address of this host.

- *

- * The IP address is represented as a 4-byte array where the first

- * octet of the IP address is put in the first member of the 4-byte

- * array.

- *

- * Example:

- \code

- uip_ipaddr_t hostaddr;

-

- uip_gethostaddr(&hostaddr);

- \endcode

- * \param addr A pointer to a uip_ipaddr_t variable that will be

- * filled in with the currently configured IP address.

- *

- * \hideinitializer

- */

-#define uip_gethostaddr(addr) uip_ipaddr_copy((addr), &uip_hostaddr)

-

-/**

- * Set the default router's IP address.

- *

- * \param addr A pointer to a uip_ipaddr_t variable containing the IP

- * address of the default router.

- *

- * \sa uip_ipaddr()

- *

- * \hideinitializer

- */

-#define uip_setdraddr(addr) uip_ipaddr_copy(&uip_draddr, (addr))

-

-/**

- * Set the netmask.

- *

- * \param addr A pointer to a uip_ipaddr_t variable containing the IP

- * address of the netmask.

- *

- * \sa uip_ipaddr()

- *

- * \hideinitializer

- */

-#define uip_setnetmask(addr) uip_ipaddr_copy(&uip_netmask, (addr))

-

-

-/**

- * Get the default router's IP address.

- *

- * \param addr A pointer to a uip_ipaddr_t variable that will be

- * filled in with the IP address of the default router.

- *

- * \hideinitializer

- */

-#define uip_getdraddr(addr) uip_ipaddr_copy((addr), &uip_draddr)

-

-/**

- * Get the netmask.

- *

- * \param addr A pointer to a uip_ipaddr_t variable that will be

- * filled in with the value of the netmask.

- *

- * \hideinitializer

- */

-#define uip_getnetmask(addr) uip_ipaddr_copy((addr), &uip_netmask)

-

-/** @} */

-

-/**

- * \defgroup uipinit uIP initialization functions

- * @{

- *

- * The uIP initialization functions are used for booting uIP.

- */

-

-/**

- * uIP initialization function.

- *

- * This function should be called at boot up to initilize the uIP

- * TCP/IP stack.

- */

-void uip_init(void);

-

-/**

- * uIP initialization function.

- *

- * This function may be used at boot time to set the initial ip_id.

- */

-void uip_setipid(u16_t id);

-

-/** @} */

-

-/**

- * \defgroup uipdevfunc uIP device driver functions

- * @{

- *

- * These functions are used by a network device driver for interacting

- * with uIP.

- */

-

-/**

- * Process an incoming packet.

- *

- * This function should be called when the device driver has received

- * a packet from the network. The packet from the device driver must

- * be present in the uip_buf buffer, and the length of the packet

- * should be placed in the uip_len variable.

- *

- * When the function returns, there may be an outbound packet placed

- * in the uip_buf packet buffer. If so, the uip_len variable is set to

- * the length of the packet. If no packet is to be sent out, the

- * uip_len variable is set to 0.

- *

- * The usual way of calling the function is presented by the source

- * code below.

- \code

- uip_len = devicedriver_poll();

- if(uip_len > 0) {

- uip_input();

- if(uip_len > 0) {

- devicedriver_send();

- }

- }

- \endcode

- *

- * \note If you are writing a uIP device driver that needs ARP

- * (Address Resolution Protocol), e.g., when running uIP over

- * Ethernet, you will need to call the uIP ARP code before calling

- * this function:

- \code

- #define BUF ((struct uip_eth_hdr *)&uip_buf[0])

- uip_len = ethernet_devicedrver_poll();

- if(uip_len > 0) {

- if(BUF->type == HTONS(UIP_ETHTYPE_IP)) {

- uip_arp_ipin();

- uip_input();

- if(uip_len > 0) {

- uip_arp_out();

- ethernet_devicedriver_send();

- }

- } else if(BUF->type == HTONS(UIP_ETHTYPE_ARP)) {

- uip_arp_arpin();

- if(uip_len > 0) {

- ethernet_devicedriver_send();

- }

- }

- \endcode

- *

- * \hideinitializer

- */

-#define uip_input()        uip_process(UIP_DATA)

-

-

-/**

- * Periodic processing for a connection identified by its number.

- *

- * This function does the necessary periodic processing (timers,

- * polling) for a uIP TCP conneciton, and should be called when the

- * periodic uIP timer goes off. It should be called for every

- * connection, regardless of whether they are open of closed.

- *

- * When the function returns, it may have an outbound packet waiting

- * for service in the uIP packet buffer, and if so the uip_len

- * variable is set to a value larger than zero. The device driver

- * should be called to send out the packet.

- *

- * The usual way of calling the function is through a for() loop like

- * this:

- \code

- for(i = 0; i < UIP_CONNS; ++i) {

- uip_periodic(i);

- if(uip_len > 0) {

- devicedriver_send();

- }

- }

- \endcode

- *

- * \note If you are writing a uIP device driver that needs ARP

- * (Address Resolution Protocol), e.g., when running uIP over

- * Ethernet, you will need to call the uip_arp_out() function before

- * calling the device driver:

- \code

- for(i = 0; i < UIP_CONNS; ++i) {

- uip_periodic(i);

- if(uip_len > 0) {

- uip_arp_out();

- ethernet_devicedriver_send();

- }

- }

- \endcode

- *

- * \param conn The number of the connection which is to be periodically polled.

- *

- * \hideinitializer

- */

-#if UIP_TCP

-#define uip_periodic(conn) do { uip_conn = &uip_conns[conn];    \

-    uip_process(UIP_TIMER); } while (0)

-

-/**

- *

- *

- */

-#define uip_conn_active(conn) (uip_conns[conn].tcpstateflags != UIP_CLOSED)

-

-/**

- * Perform periodic processing for a connection identified by a pointer

- * to its structure.

- *

- * Same as uip_periodic() but takes a pointer to the actual uip_conn

- * struct instead of an integer as its argument. This function can be

- * used to force periodic processing of a specific connection.

- *

- * \param conn A pointer to the uip_conn struct for the connection to

- * be processed.

- *

- * \hideinitializer

- */

-#define uip_periodic_conn(conn) do { uip_conn = conn;   \

-    uip_process(UIP_TIMER); } while (0)

-

-/**

- * Request that a particular connection should be polled.

- *

- * Similar to uip_periodic_conn() but does not perform any timer

- * processing. The application is polled for new data.

- *

- * \param conn A pointer to the uip_conn struct for the connection to

- * be processed.

- *

- * \hideinitializer

- */

-#define uip_poll_conn(conn) do { uip_conn = conn;       \

-    uip_process(UIP_POLL_REQUEST); } while (0)

-

-#endif /* UIP_TCP */

-

-#if UIP_UDP

-/**

- * Periodic processing for a UDP connection identified by its number.

- *

- * This function is essentially the same as uip_periodic(), but for

- * UDP connections. It is called in a similar fashion as the

- * uip_periodic() function:

- \code

- for(i = 0; i < UIP_UDP_CONNS; i++) {

- uip_udp_periodic(i);

- if(uip_len > 0) {

- devicedriver_send();

- }

- }

- \endcode

- *

- * \note As for the uip_periodic() function, special care has to be

- * taken when using uIP together with ARP and Ethernet:

- \code

- for(i = 0; i < UIP_UDP_CONNS; i++) {

- uip_udp_periodic(i);

- if(uip_len > 0) {

- uip_arp_out();

- ethernet_devicedriver_send();

- }

- }

- \endcode

- *

- * \param conn The number of the UDP connection to be processed.

- *

- * \hideinitializer

- */

-#define uip_udp_periodic(conn) do { uip_udp_conn = &uip_udp_conns[conn]; \

-    uip_process(UIP_UDP_TIMER); } while(0)

-

-/**

- * Periodic processing for a UDP connection identified by a pointer to

- * its structure.

- *

- * Same as uip_udp_periodic() but takes a pointer to the actual

- * uip_conn struct instead of an integer as its argument. This

- * function can be used to force periodic processing of a specific

- * connection.

- *

- * \param conn A pointer to the uip_udp_conn struct for the connection

- * to be processed.

- *

- * \hideinitializer

- */

-#define uip_udp_periodic_conn(conn) do { uip_udp_conn = conn;   \

-    uip_process(UIP_UDP_TIMER); } while(0)

-#endif /* UIP_UDP */

-

-/** \brief Abandon the reassembly of the current packet */

-void uip_reass_over(void);

-

-/**

- * The uIP packet buffer.

- *

- * The uip_buf array is used to hold incoming and outgoing

- * packets. The device driver should place incoming data into this

- * buffer. When sending data, the device driver should read the link

- * level headers and the TCP/IP headers from this buffer. The size of

- * the link level headers is configured by the UIP_LLH_LEN define.

- *

- * \note The application data need not be placed in this buffer, so

- * the device driver must read it from the place pointed to by the

- * uip_appdata pointer as illustrated by the following example:

- \code

- void

- devicedriver_send(void)

- {

- hwsend(&uip_buf[0], UIP_LLH_LEN);

- if(uip_len <= UIP_LLH_LEN + UIP_TCPIP_HLEN) {

- hwsend(&uip_buf[UIP_LLH_LEN], uip_len - UIP_LLH_LEN);

- } else {

- hwsend(&uip_buf[UIP_LLH_LEN], UIP_TCPIP_HLEN);

- hwsend(uip_appdata, uip_len - UIP_TCPIP_HLEN - UIP_LLH_LEN);

- }

- }

- \endcode

-*/

-extern u8_t uip_buf[UIP_BUFSIZE+2];

-

-

-

-/** @} */

-

-/*---------------------------------------------------------------------------*/

-/* Functions that are used by the uIP application program. Opening and

- * closing connections, sending and receiving data, etc. is all

- * handled by the functions below.

- */

-/**

- * \defgroup uipappfunc uIP application functions

- * @{

- *

- * Functions used by an application running of top of uIP.

- */

-

-/**

- * Start listening to the specified port.

- *

- * \note Since this function expects the port number in network byte

- * order, a conversion using HTONS() or htons() is necessary.

- *

- \code

- uip_listen(HTONS(80));

- \endcode

- *

- * \param port A 16-bit port number in network byte order.

- */

-void uip_listen(u16_t port);

-

-/**

- * Stop listening to the specified port.

- *

- * \note Since this function expects the port number in network byte

- * order, a conversion using HTONS() or htons() is necessary.

- *

- \code

- uip_unlisten(HTONS(80));

- \endcode

- *

- * \param port A 16-bit port number in network byte order.

- */

-void uip_unlisten(u16_t port);

-

-/**

- * Connect to a remote host using TCP.

- *

- * This function is used to start a new connection to the specified

- * port on the specified host. It allocates a new connection identifier,

- * sets the connection to the SYN_SENT state and sets the

- * retransmission timer to 0. This will cause a TCP SYN segment to be

- * sent out the next time this connection is periodically processed,

- * which usually is done within 0.5 seconds after the call to

- * uip_connect().

- *

- * \note This function is available only if support for active open

- * has been configured by defining UIP_ACTIVE_OPEN to 1 in uipopt.h.

- *

- * \note Since this function requires the port number to be in network

- * byte order, a conversion using HTONS() or htons() is necessary.

- *

- \code

- uip_ipaddr_t ipaddr;

-

- uip_ipaddr(&ipaddr, 192,168,1,2);

- uip_connect(&ipaddr, HTONS(80));

- \endcode

- *

- * \param ripaddr The IP address of the remote host.

- *

- * \param port A 16-bit port number in network byte order.

- *

- * \return A pointer to the uIP connection identifier for the new connection,

- * or NULL if no connection could be allocated.

- *

- */

-struct uip_conn *uip_connect(uip_ipaddr_t *ripaddr, u16_t port);

-

-

-

-/**

- * \internal

- *

- * Check if a connection has outstanding (i.e., unacknowledged) data.

- *

- * \param conn A pointer to the uip_conn structure for the connection.

- *

- * \hideinitializer

- */

-#define uip_outstanding(conn) ((conn)->len)

-

-/**

- * Send data on the current connection.

- *

- * This function is used to send out a single segment of TCP

- * data. Only applications that have been invoked by uIP for event

- * processing can send data.

- *

- * The amount of data that actually is sent out after a call to this

- * function is determined by the maximum amount of data TCP allows. uIP

- * will automatically crop the data so that only the appropriate

- * amount of data is sent. The function uip_mss() can be used to query

- * uIP for the amount of data that actually will be sent.

- *

- * \note This function does not guarantee that the sent data will

- * arrive at the destination. If the data is lost in the network, the

- * application will be invoked with the uip_rexmit() event being

- * set. The application will then have to resend the data using this

- * function.

- *

- * \param data A pointer to the data which is to be sent.

- *

- * \param len The maximum amount of data bytes to be sent.

- *

- * \hideinitializer

- */

-void uip_send(const void *data, int len);

-

-/**

- * The length of any incoming data that is currently available (if available)

- * in the uip_appdata buffer.

- *

- * The test function uip_data() must first be used to check if there

- * is any data available at all.

- *

- * \hideinitializer

- */

-/*void uip_datalen(void);*/

-#define uip_datalen()       uip_len

-

-/**

- * The length of any out-of-band data (urgent data) that has arrived

- * on the connection.

- *

- * \note The configuration parameter UIP_URGDATA must be set for this

- * function to be enabled.

- *

- * \hideinitializer

- */

-#define uip_urgdatalen()    uip_urglen

-

-/**

- * Close the current connection.

- *

- * This function will close the current connection in a nice way.

- *

- * \hideinitializer

- */

-#define uip_close()         (uip_flags = UIP_CLOSE)

-

-/**

- * Abort the current connection.

- *

- * This function will abort (reset) the current connection, and is

- * usually used when an error has occurred that prevents using the

- * uip_close() function.

- *

- * \hideinitializer

- */

-#define uip_abort()         (uip_flags = UIP_ABORT)

-

-/**

- * Tell the sending host to stop sending data.

- *

- * This function will close our receiver's window so that we stop

- * receiving data for the current connection.

- *

- * \hideinitializer

- */

-#define uip_stop()          (uip_conn->tcpstateflags |= UIP_STOPPED)

-

-/**

- * Find out if the current connection has been previously stopped with

- * uip_stop().

- *

- * \hideinitializer

- */

-#define uip_stopped(conn)   ((conn)->tcpstateflags & UIP_STOPPED)

-

-/**

- * Restart the current connection, if is has previously been stopped

- * with uip_stop().

- *

- * This function will open the receiver's window again so that we

- * start receiving data for the current connection.

- *

- * \hideinitializer

- */

-#define uip_restart()         do { uip_flags |= UIP_NEWDATA;    \

-    uip_conn->tcpstateflags &= ~UIP_STOPPED;                    \

-  } while(0)

-

-

-/* uIP tests that can be made to determine in what state the current

-   connection is, and what the application function should do. */

-

-/**

- * Is the current connection a UDP connection?

- *

- * This function checks whether the current connection is a UDP connection.

- *

- * \hideinitializer

- *

- */

-#define uip_udpconnection() (uip_conn == NULL)

-

-/**

- * Is new incoming data available?

- *

- * Will reduce to non-zero if there is new data for the application

- * present at the uip_appdata pointer. The size of the data is

- * available through the uip_len variable.

- *

- * \hideinitializer

- */

-#define uip_newdata()   (uip_flags & UIP_NEWDATA)

-

-/**

- * Has previously sent data been acknowledged?

- *

- * Will reduce to non-zero if the previously sent data has been

- * acknowledged by the remote host. This means that the application

- * can send new data.

- *

- * \hideinitializer

- */

-#define uip_acked()   (uip_flags & UIP_ACKDATA)

-

-/**

- * Has the connection just been connected?

- *

- * Reduces to non-zero if the current connection has been connected to

- * a remote host. This will happen both if the connection has been

- * actively opened (with uip_connect()) or passively opened (with

- * uip_listen()).

- *

- * \hideinitializer

- */

-#define uip_connected() (uip_flags & UIP_CONNECTED)

-

-/**

- * Has the connection been closed by the other end?

- *

- * Is non-zero if the connection has been closed by the remote

- * host. The application may then do the necessary clean-ups.

- *

- * \hideinitializer

- */

-#define uip_closed()    (uip_flags & UIP_CLOSE)

-

-/**

- * Has the connection been aborted by the other end?

- *

- * Non-zero if the current connection has been aborted (reset) by the

- * remote host.

- *

- * \hideinitializer

- */

-#define uip_aborted()    (uip_flags & UIP_ABORT)

-

-/**

- * Has the connection timed out?

- *

- * Non-zero if the current connection has been aborted due to too many

- * retransmissions.

- *

- * \hideinitializer

- */

-#define uip_timedout()    (uip_flags & UIP_TIMEDOUT)

-

-/**

- * Do we need to retransmit previously data?

- *

- * Reduces to non-zero if the previously sent data has been lost in

- * the network, and the application should retransmit it. The

- * application should send the exact same data as it did the last

- * time, using the uip_send() function.

- *

- * \hideinitializer

- */

-#define uip_rexmit()     (uip_flags & UIP_REXMIT)

-

-/**

- * Is the connection being polled by uIP?

- *

- * Is non-zero if the reason the application is invoked is that the

- * current connection has been idle for a while and should be

- * polled.

- *

- * The polling event can be used for sending data without having to

- * wait for the remote host to send data.

- *

- * \hideinitializer

- */

-#define uip_poll()       (uip_flags & UIP_POLL)

-

-/**

- * Get the initial maximum segment size (MSS) of the current

- * connection.

- *

- * \hideinitializer

- */

-#define uip_initialmss()             (uip_conn->initialmss)

-

-/**

- * Get the current maximum segment size that can be sent on the current

- * connection.

- *

- * The current maximum segment size that can be sent on the

- * connection is computed from the receiver's window and the MSS of

- * the connection (which also is available by calling

- * uip_initialmss()).

- *

- * \hideinitializer

- */

-#define uip_mss()             (uip_conn->mss)

-

-/**

- * Set up a new UDP connection.

- *

- * This function sets up a new UDP connection. The function will

- * automatically allocate an unused local port for the new

- * connection. However, another port can be chosen by using the

- * uip_udp_bind() call, after the uip_udp_new() function has been

- * called.

- *

- * Example:

- \code

- uip_ipaddr_t addr;

- struct uip_udp_conn *c;

- 

- uip_ipaddr(&addr, 192,168,2,1);

- c = uip_udp_new(&addr, HTONS(12345));

- if(c != NULL) {

- uip_udp_bind(c, HTONS(12344));

- }

- \endcode

- * \param ripaddr The IP address of the remote host.

- *

- * \param rport The remote port number in network byte order.

- *

- * \return The uip_udp_conn structure for the new connection or NULL

- * if no connection could be allocated.

- */

-struct uip_udp_conn *uip_udp_new(const uip_ipaddr_t *ripaddr, u16_t rport);

-

-/**

- * Removed a UDP connection.

- *

- * \param conn A pointer to the uip_udp_conn structure for the connection.

- *

- * \hideinitializer

- */

-#define uip_udp_remove(conn) (conn)->lport = 0

-

-/**

- * Bind a UDP connection to a local port.

- *

- * \param conn A pointer to the uip_udp_conn structure for the

- * connection.

- *

- * \param port The local port number, in network byte order.

- *

- * \hideinitializer

- */

-#define uip_udp_bind(conn, port) (conn)->lport = port

-

-/**

- * Send a UDP datagram of length len on the current connection.

- *

- * This function can only be called in response to a UDP event (poll

- * or newdata). The data must be present in the uip_buf buffer, at the

- * place pointed to by the uip_appdata pointer.

- *

- * \param len The length of the data in the uip_buf buffer.

- *

- * \hideinitializer

- */

-#define uip_udp_send(len) uip_send((char *)uip_appdata, len)

-

-/** @} */

-

-/* uIP convenience and converting functions. */

-

-/**

- * \defgroup uipconvfunc uIP conversion functions

- * @{

- *

- * These functions can be used for converting between different data

- * formats used by uIP.

- */

- 

-/**

- * Convert an IP address to four bytes separated by commas.

- *

- * Example:

- \code

- uip_ipaddr_t ipaddr;

- printf("ipaddr=%d.%d.%d.%d\n", uip_ipaddr_to_quad(&ipaddr));

- \endcode

- *

- * \param a A pointer to a uip_ipaddr_t.

- * \hideinitializer

- */

-#define uip_ipaddr_to_quad(a) (a)->u8[0],(a)->u8[1],(a)->u8[2],(a)->u8[3]

-

-/**

- * Construct an IP address from four bytes.

- *

- * This function constructs an IP address of the type that uIP handles

- * internally from four bytes. The function is handy for specifying IP

- * addresses to use with e.g. the uip_connect() function.

- *

- * Example:

- \code

- uip_ipaddr_t ipaddr;

- struct uip_conn *c;

- 

- uip_ipaddr(&ipaddr, 192,168,1,2);

- c = uip_connect(&ipaddr, HTONS(80));

- \endcode

- *

- * \param addr A pointer to a uip_ipaddr_t variable that will be

- * filled in with the IP address.

- *

- * \param addr0 The first octet of the IP address.

- * \param addr1 The second octet of the IP address.

- * \param addr2 The third octet of the IP address.

- * \param addr3 The forth octet of the IP address.

- *

- * \hideinitializer

- */

-#define uip_ipaddr(addr, addr0,addr1,addr2,addr3) do {  \

-    (addr)->u8[0] = addr0;                              \

-    (addr)->u8[1] = addr1;                              \

-    (addr)->u8[2] = addr2;                              \

-    (addr)->u8[3] = addr3;                              \

-  } while(0)

-

-/**

- * Construct an IPv6 address from eight 16-bit words.

- *

- * This function constructs an IPv6 address.

- *

- * \hideinitializer

- */

-#define uip_ip6addr(addr, addr0,addr1,addr2,addr3,addr4,addr5,addr6,addr7) do { \

-    (addr)->u16[0] = HTONS(addr0);                                      \

-    (addr)->u16[1] = HTONS(addr1);                                      \

-    (addr)->u16[2] = HTONS(addr2);                                      \

-    (addr)->u16[3] = HTONS(addr3);                                      \

-    (addr)->u16[4] = HTONS(addr4);                                      \

-    (addr)->u16[5] = HTONS(addr5);                                      \

-    (addr)->u16[6] = HTONS(addr6);                                      \

-    (addr)->u16[7] = HTONS(addr7);                                      \

-  } while(0)

-

-/**

- * Construct an IPv6 address from eight 8-bit words.

- *

- * This function constructs an IPv6 address.

- *

- * \hideinitializer

- */

-#define uip_ip6addr_u8(addr, addr0,addr1,addr2,addr3,addr4,addr5,addr6,addr7,addr8,addr9,addr10,addr11,addr12,addr13,addr14,addr15) do { \

-    (addr)->u8[0] = addr0;                                       \

-    (addr)->u8[1] = addr1;                                       \

-    (addr)->u8[2] = addr2;                                       \

-    (addr)->u8[3] = addr3;                                       \

-    (addr)->u8[4] = addr4;                                       \

-    (addr)->u8[5] = addr5;                                       \

-    (addr)->u8[6] = addr6;                                       \

-    (addr)->u8[7] = addr7;                                       \

-    (addr)->u8[8] = addr8;                                       \

-    (addr)->u8[9] = addr9;                                       \

-    (addr)->u8[10] = addr10;                                     \

-    (addr)->u8[11] = addr11;                                     \

-    (addr)->u8[12] = addr12;                                     \

-    (addr)->u8[13] = addr13;                                     \

-    (addr)->u8[14] = addr14;                                     \

-    (addr)->u8[15] = addr15;                                     \

-  } while(0)

-

-

-/**

- * Copy an IP address to another IP address.

- *

- * Copies an IP address from one place to another.

- *

- * Example:

- \code

- uip_ipaddr_t ipaddr1, ipaddr2;

-

- uip_ipaddr(&ipaddr1, 192,16,1,2);

- uip_ipaddr_copy(&ipaddr2, &ipaddr1);

- \endcode

- *

- * \param dest The destination for the copy.

- * \param src The source from where to copy.

- *

- * \hideinitializer

- */

-#ifndef uip_ipaddr_copy

-#define uip_ipaddr_copy(dest, src) (*(dest) = *(src))

-#endif

-

-/**

- * Compare two IP addresses

- *

- * Compares two IP addresses.

- *

- * Example:

- \code

- uip_ipaddr_t ipaddr1, ipaddr2;

-

- uip_ipaddr(&ipaddr1, 192,16,1,2);

- if(uip_ipaddr_cmp(&ipaddr2, &ipaddr1)) {

- printf("They are the same");

- }

- \endcode

- *

- * \param addr1 The first IP address.

- * \param addr2 The second IP address.

- *

- * \hideinitializer

- */

-#if !UIP_CONF_IPV6

-#define uip_ipaddr_cmp(addr1, addr2) ((addr1)->u16[0] == (addr2)->u16[0] && \

-				      (addr1)->u16[1] == (addr2)->u16[1])

-#else /* !UIP_CONF_IPV6 */

-#define uip_ipaddr_cmp(addr1, addr2) (memcmp(addr1, addr2, sizeof(uip_ip6addr_t)) == 0)

-#endif /* !UIP_CONF_IPV6 */

-

-/**

- * Compare two IP addresses with netmasks

- *

- * Compares two IP addresses with netmasks. The masks are used to mask

- * out the bits that are to be compared.

- *

- * Example:

- \code

- uip_ipaddr_t ipaddr1, ipaddr2, mask;

-

- uip_ipaddr(&mask, 255,255,255,0);

- uip_ipaddr(&ipaddr1, 192,16,1,2);

- uip_ipaddr(&ipaddr2, 192,16,1,3);

- if(uip_ipaddr_maskcmp(&ipaddr1, &ipaddr2, &mask)) {

- printf("They are the same");

- }

- \endcode

- *

- * \param addr1 The first IP address.

- * \param addr2 The second IP address.

- * \param mask The netmask.

- *

- * \hideinitializer

- */

-#if !UIP_CONF_IPV6

-#define uip_ipaddr_maskcmp(addr1, addr2, mask)          \

-  (((((u16_t *)addr1)[0] & ((u16_t *)mask)[0]) ==       \

-    (((u16_t *)addr2)[0] & ((u16_t *)mask)[0])) &&      \

-   ((((u16_t *)addr1)[1] & ((u16_t *)mask)[1]) ==       \

-    (((u16_t *)addr2)[1] & ((u16_t *)mask)[1])))

-#else

-#define uip_ipaddr_prefixcmp(addr1, addr2, length) (memcmp(addr1, addr2, length>>3) == 0)

-#endif

-

-

-/**

- * Check if an address is a broadcast address for a network.

- *

- * Checks if an address is the broadcast address for a network. The

- * network is defined by an IP address that is on the network and the

- * network's netmask.

- *

- * \param addr The IP address.

- * \param netaddr The network's IP address.

- * \param netmask The network's netmask.

- *

- * \hideinitializer

- */

-/*#define uip_ipaddr_isbroadcast(addr, netaddr, netmask)

-  ((uip_ipaddr_t *)(addr)).u16 & ((uip_ipaddr_t *)(addr)).u16*/

-

-

-

-/**

- * Mask out the network part of an IP address.

- *

- * Masks out the network part of an IP address, given the address and

- * the netmask.

- *

- * Example:

- \code

- uip_ipaddr_t ipaddr1, ipaddr2, netmask;

-

- uip_ipaddr(&ipaddr1, 192,16,1,2);

- uip_ipaddr(&netmask, 255,255,255,0);

- uip_ipaddr_mask(&ipaddr2, &ipaddr1, &netmask);

- \endcode

- *

- * In the example above, the variable "ipaddr2" will contain the IP

- * address 192.168.1.0.

- *

- * \param dest Where the result is to be placed.

- * \param src The IP address.

- * \param mask The netmask.

- *

- * \hideinitializer

- */

-#define uip_ipaddr_mask(dest, src, mask) do {                           \

-    ((u16_t *)dest)[0] = ((u16_t *)src)[0] & ((u16_t *)mask)[0];        \

-    ((u16_t *)dest)[1] = ((u16_t *)src)[1] & ((u16_t *)mask)[1];        \

-  } while(0)

-

-/**

- * Pick the first octet of an IP address.

- *

- * Picks out the first octet of an IP address.

- *

- * Example:

- \code

- uip_ipaddr_t ipaddr;

- u8_t octet;

-

- uip_ipaddr(&ipaddr, 1,2,3,4);

- octet = uip_ipaddr1(&ipaddr);

- \endcode

- *

- * In the example above, the variable "octet" will contain the value 1.

- *

- * \hideinitializer

- */

-#define uip_ipaddr1(addr) ((addr)->u8[0])

-

-/**

- * Pick the second octet of an IP address.

- *

- * Picks out the second octet of an IP address.

- *

- * Example:

- \code

- uip_ipaddr_t ipaddr;

- u8_t octet;

-

- uip_ipaddr(&ipaddr, 1,2,3,4);

- octet = uip_ipaddr2(&ipaddr);

- \endcode

- *

- * In the example above, the variable "octet" will contain the value 2.

- *

- * \hideinitializer

- */

-#define uip_ipaddr2(addr) ((addr)->u8[1])

-

-/**

- * Pick the third octet of an IP address.

- *

- * Picks out the third octet of an IP address.

- *

- * Example:

- \code

- uip_ipaddr_t ipaddr;

- u8_t octet;

-

- uip_ipaddr(&ipaddr, 1,2,3,4);

- octet = uip_ipaddr3(&ipaddr);

- \endcode

- *

- * In the example above, the variable "octet" will contain the value 3.

- *

- * \hideinitializer

- */

-#define uip_ipaddr3(addr) ((addr)->u8[2])

-

-/**

- * Pick the fourth octet of an IP address.

- *

- * Picks out the fourth octet of an IP address.

- *

- * Example:

- \code

- uip_ipaddr_t ipaddr;

- u8_t octet;

-

- uip_ipaddr(&ipaddr, 1,2,3,4);

- octet = uip_ipaddr4(&ipaddr);

- \endcode

- *

- * In the example above, the variable "octet" will contain the value 4.

- *

- * \hideinitializer

- */

-#define uip_ipaddr4(addr) ((addr)->u8[3])

-

-/**

- * Convert 16-bit quantity from host byte order to network byte order.

- *

- * This macro is primarily used for converting constants from host

- * byte order to network byte order. For converting variables to

- * network byte order, use the htons() function instead.

- *

- * \hideinitializer

- */

-#ifndef HTONS

-#   if UIP_BYTE_ORDER == UIP_BIG_ENDIAN

-#      define HTONS(n) (n)

-#      define HTONL(n) (n)

-#   else /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */

-#      define HTONS(n) (u16_t)((((u16_t) (n)) << 8) | (((u16_t) (n)) >> 8))

-#      define HTONL(n) (((u32_t)HTONS(n) << 16) | HTONS((u32_t)(n) >> 16))

-#   endif /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */

-#else

-#error "HTONS already defined!"

-#endif /* HTONS */

-

-/**

- * Convert 16-bit quantity from host byte order to network byte order.

- *

- * This function is primarily used for converting variables from host

- * byte order to network byte order. For converting constants to

- * network byte order, use the HTONS() macro instead.

- */

-#ifndef htons

-u16_t htons(u16_t val);

-#endif /* htons */

-#ifndef ntohs

-#define ntohs htons

-#endif

-

-#ifndef htonl

-u32_t htonl(u32_t val);

-#endif /* htonl */

-#ifndef ntohl

-#define ntohl htonl

-#endif

-

-/** @} */

-

-/**

- * Pointer to the application data in the packet buffer.

- *

- * This pointer points to the application data when the application is

- * called. If the application wishes to send data, the application may

- * use this space to write the data into before calling uip_send().

- */

-extern void *uip_appdata;

-

-#if UIP_URGDATA > 0

-/* u8_t *uip_urgdata:

- *

- * This pointer points to any urgent data that has been received. Only

- * present if compiled with support for urgent data (UIP_URGDATA).

- */

-extern void *uip_urgdata;

-#endif /* UIP_URGDATA > 0 */

-

-

-/**

- * \defgroup uipdrivervars Variables used in uIP device drivers

- * @{

- *

- * uIP has a few global variables that are used in device drivers for

- * uIP.

- */

-

-/**

- * The length of the packet in the uip_buf buffer.

- *

- * The global variable uip_len holds the length of the packet in the

- * uip_buf buffer.

- *

- * When the network device driver calls the uIP input function,

- * uip_len should be set to the length of the packet in the uip_buf

- * buffer.

- *

- * When sending packets, the device driver should use the contents of

- * the uip_len variable to determine the length of the outgoing

- * packet.

- *

- */

-extern u16_t uip_len;

-

-/**

- * The length of the extension headers

- */

-extern u8_t uip_ext_len;

-/** @} */

-

-#if UIP_URGDATA > 0

-extern u16_t uip_urglen, uip_surglen;

-#endif /* UIP_URGDATA > 0 */

-

-

-/**

- * Representation of a uIP TCP connection.

- *

- * The uip_conn structure is used for identifying a connection. All

- * but one field in the structure are to be considered read-only by an

- * application. The only exception is the appstate field whose purpose

- * is to let the application store application-specific state (e.g.,

- * file pointers) for the connection. The type of this field is

- * configured in the "uipopt.h" header file.

- */

-struct uip_conn {

-  uip_ipaddr_t ripaddr;   /**< The IP address of the remote host. */

-  

-  u16_t lport;        /**< The local TCP port, in network byte order. */

-  u16_t rport;        /**< The local remote TCP port, in network byte

-			 order. */

-  

-  u8_t rcv_nxt[4];    /**< The sequence number that we expect to

-			 receive next. */

-  u8_t snd_nxt[4];    /**< The sequence number that was last sent by

-                         us. */

-  u16_t len;          /**< Length of the data that was previously sent. */

-  u16_t mss;          /**< Current maximum segment size for the

-			 connection. */

-  u16_t initialmss;   /**< Initial maximum segment size for the

-			 connection. */

-  u8_t sa;            /**< Retransmission time-out calculation state

-			 variable. */

-  u8_t sv;            /**< Retransmission time-out calculation state

-			 variable. */

-  u8_t rto;           /**< Retransmission time-out. */

-  u8_t tcpstateflags; /**< TCP state and flags. */

-  u8_t timer;         /**< The retransmission timer. */

-  u8_t nrtx;          /**< The number of retransmissions for the last

-			 segment sent. */

-

-  /** The application state. */

-  uip_tcp_appstate_t appstate;

-};

-

-

-/**

- * Pointer to the current TCP connection.

- *

- * The uip_conn pointer can be used to access the current TCP

- * connection.

- */

-

-extern struct uip_conn *uip_conn;

-#if UIP_TCP

-/* The array containing all uIP connections. */

-extern struct uip_conn uip_conns[UIP_CONNS];

-#endif

-

-/**

- * \addtogroup uiparch

- * @{

- */

-

-/**

- * 4-byte array used for the 32-bit sequence number calculations.

- */

-extern u8_t uip_acc32[4];

-/** @} */

-

-/**

- * Representation of a uIP UDP connection.

- */

-struct uip_udp_conn {

-  uip_ipaddr_t ripaddr;   /**< The IP address of the remote peer. */

-  u16_t lport;        /**< The local port number in network byte order. */

-  u16_t rport;        /**< The remote port number in network byte order. */

-  u8_t  ttl;          /**< Default time-to-live. */

-

-  /** The application state. */

-  uip_udp_appstate_t appstate;

-};

-

-/**

- * The current UDP connection.

- */

-extern struct uip_udp_conn *uip_udp_conn;

-extern struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];

-

-struct uip_router {

-  int (*activate)(void);

-  int (*deactivate)(void);

-  uip_ipaddr_t *(*lookup)(uip_ipaddr_t *destipaddr, uip_ipaddr_t *nexthop);

-};

-

-#if UIP_CONF_ROUTER

-extern const struct uip_router *uip_router;

-

-/**

- * uIP routing driver registration function.

- */

-void uip_router_register(const struct uip_router *router);

-#endif /*UIP_CONF_ROUTER*/

-

-#if UIP_CONF_ICMP6

-struct uip_icmp6_conn {

-  uip_icmp6_appstate_t appstate;

-};

-extern struct uip_icmp6_conn uip_icmp6_conns;

-#endif /*UIP_CONF_ICMP6*/

-

-/**

- * The uIP TCP/IP statistics.

- *

- * This is the variable in which the uIP TCP/IP statistics are gathered.

- */

-#if UIP_STATISTICS == 1

-extern struct uip_stats uip_stat;

-#define UIP_STAT(s) s

-#else

-#define UIP_STAT(s)

-#endif /* UIP_STATISTICS == 1 */

-

-/**

- * The structure holding the TCP/IP statistics that are gathered if

- * UIP_STATISTICS is set to 1.

- *

- */

-struct uip_stats {

-  struct {

-    uip_stats_t recv;     /**< Number of received packets at the IP

-			     layer. */

-    uip_stats_t sent;     /**< Number of sent packets at the IP

-			     layer. */

-    uip_stats_t forwarded;/**< Number of forwarded packets at the IP 

-			     layer. */

-    uip_stats_t drop;     /**< Number of dropped packets at the IP

-			     layer. */

-    uip_stats_t vhlerr;   /**< Number of packets dropped due to wrong

-			     IP version or header length. */

-    uip_stats_t hblenerr; /**< Number of packets dropped due to wrong

-			     IP length, high byte. */

-    uip_stats_t lblenerr; /**< Number of packets dropped due to wrong

-			     IP length, low byte. */

-    uip_stats_t fragerr;  /**< Number of packets dropped since they

-			     were IP fragments. */

-    uip_stats_t chkerr;   /**< Number of packets dropped due to IP

-			     checksum errors. */

-    uip_stats_t protoerr; /**< Number of packets dropped since they

-			     were neither ICMP, UDP nor TCP. */

-  } ip;                   /**< IP statistics. */

-  struct {

-    uip_stats_t recv;     /**< Number of received ICMP packets. */

-    uip_stats_t sent;     /**< Number of sent ICMP packets. */

-    uip_stats_t drop;     /**< Number of dropped ICMP packets. */

-    uip_stats_t typeerr;  /**< Number of ICMP packets with a wrong

-			     type. */

-    uip_stats_t chkerr;   /**< Number of ICMP packets with a bad

-			     checksum. */

-  } icmp;                 /**< ICMP statistics. */

-#if UIP_TCP

-  struct {

-    uip_stats_t recv;     /**< Number of recived TCP segments. */

-    uip_stats_t sent;     /**< Number of sent TCP segments. */

-    uip_stats_t drop;     /**< Number of dropped TCP segments. */

-    uip_stats_t chkerr;   /**< Number of TCP segments with a bad

-			     checksum. */

-    uip_stats_t ackerr;   /**< Number of TCP segments with a bad ACK

-			     number. */

-    uip_stats_t rst;      /**< Number of recevied TCP RST (reset) segments. */

-    uip_stats_t rexmit;   /**< Number of retransmitted TCP segments. */

-    uip_stats_t syndrop;  /**< Number of dropped SYNs due to too few

-			     connections was avaliable. */

-    uip_stats_t synrst;   /**< Number of SYNs for closed ports,

-			     triggering a RST. */

-  } tcp;                  /**< TCP statistics. */

-#endif

-#if UIP_UDP

-  struct {

-    uip_stats_t drop;     /**< Number of dropped UDP segments. */

-    uip_stats_t recv;     /**< Number of recived UDP segments. */

-    uip_stats_t sent;     /**< Number of sent UDP segments. */

-    uip_stats_t chkerr;   /**< Number of UDP segments with a bad

-			     checksum. */

-  } udp;                  /**< UDP statistics. */

-#endif /* UIP_UDP */

-#if UIP_CONF_IPV6

-  struct {

-    uip_stats_t drop;     /**< Number of dropped ND6 packets. */

-    uip_stats_t recv;     /**< Number of recived ND6 packets */

-    uip_stats_t sent;     /**< Number of sent ND6 packets */

-  } nd6;

-#endif /*UIP_CONF_IPV6*/

-};

-

-

-/*---------------------------------------------------------------------------*/

-/* All the stuff below this point is internal to uIP and should not be

- * used directly by an application or by a device driver.

- */

-/*---------------------------------------------------------------------------*/

-

-

-

-/* u8_t uip_flags:

- *

- * When the application is called, uip_flags will contain the flags

- * that are defined in this file. Please read below for more

- * information.

- */

-extern u8_t uip_flags;

-

-/* The following flags may be set in the global variable uip_flags

-   before calling the application callback. The UIP_ACKDATA,

-   UIP_NEWDATA, and UIP_CLOSE flags may both be set at the same time,

-   whereas the others are mutually exclusive. Note that these flags

-   should *NOT* be accessed directly, but only through the uIP

-   functions/macros. */

-

-#define UIP_ACKDATA   1     /* Signifies that the outstanding data was

-			       acked and the application should send

-			       out new data instead of retransmitting

-			       the last data. */

-#define UIP_NEWDATA   2     /* Flags the fact that the peer has sent

-			       us new data. */

-#define UIP_REXMIT    4     /* Tells the application to retransmit the

-			       data that was last sent. */

-#define UIP_POLL      8     /* Used for polling the application, to

-			       check if the application has data that

-			       it wants to send. */

-#define UIP_CLOSE     16    /* The remote host has closed the

-			       connection, thus the connection has

-			       gone away. Or the application signals

-			       that it wants to close the

-			       connection. */

-#define UIP_ABORT     32    /* The remote host has aborted the

-			       connection, thus the connection has

-			       gone away. Or the application signals

-			       that it wants to abort the

-			       connection. */

-#define UIP_CONNECTED 64    /* We have got a connection from a remote

-                               host and have set up a new connection

-                               for it, or an active connection has

-                               been successfully established. */

-

-#define UIP_TIMEDOUT  128   /* The connection has been aborted due to

-			       too many retransmissions. */

-

-

-/**

- * \brief process the options within a hop by hop or destination option header

- * \retval 0: nothing to send,

- * \retval 1: drop pkt

- * \retval 2: ICMP error message to send

-*/

-/*static u8_t

-uip_ext_hdr_options_process(); */

-

-/* uip_process(flag):

- *

- * The actual uIP function which does all the work.

- */

-void uip_process(u8_t flag);

-  

-  /* The following flags are passed as an argument to the uip_process()

-   function. They are used to distinguish between the two cases where

-   uip_process() is called. It can be called either because we have

-   incoming data that should be processed, or because the periodic

-   timer has fired. These values are never used directly, but only in

-   the macros defined in this file. */

- 

-#define UIP_DATA          1     /* Tells uIP that there is incoming

-				   data in the uip_buf buffer. The

-				   length of the data is stored in the

-				   global variable uip_len. */

-#define UIP_TIMER         2     /* Tells uIP that the periodic timer

-				   has fired. */

-#define UIP_POLL_REQUEST  3     /* Tells uIP that a connection should

-				   be polled. */

-#define UIP_UDP_SEND_CONN 4     /* Tells uIP that a UDP datagram

-				   should be constructed in the

-				   uip_buf buffer. */

-#if UIP_UDP

-#define UIP_UDP_TIMER     5

-#endif /* UIP_UDP */

-

-/* The TCP states used in the uip_conn->tcpstateflags. */

-#define UIP_CLOSED      0

-#define UIP_SYN_RCVD    1

-#define UIP_SYN_SENT    2

-#define UIP_ESTABLISHED 3

-#define UIP_FIN_WAIT_1  4

-#define UIP_FIN_WAIT_2  5

-#define UIP_CLOSING     6

-#define UIP_TIME_WAIT   7

-#define UIP_LAST_ACK    8

-#define UIP_TS_MASK     15

-  

-#define UIP_STOPPED      16

-

-/* The TCP and IP headers. */

-struct uip_tcpip_hdr {

-#if UIP_CONF_IPV6

-  /* IPv6 header. */

-  u8_t vtc,

-    tcflow;

-  u16_t flow;

-  u8_t len[2];

-  u8_t proto, ttl;

-  uip_ip6addr_t srcipaddr, destipaddr;

-#else /* UIP_CONF_IPV6 */

-  /* IPv4 header. */

-  u8_t vhl,

-    tos,

-    len[2],

-    ipid[2],

-    ipoffset[2],

-    ttl,

-    proto;

-  u16_t ipchksum;

-  uip_ipaddr_t srcipaddr, destipaddr;

-#endif /* UIP_CONF_IPV6 */

-  

-  /* TCP header. */

-  u16_t srcport,

-    destport;

-  u8_t seqno[4],

-    ackno[4],

-    tcpoffset,

-    flags,

-    wnd[2];

-  u16_t tcpchksum;

-  u8_t urgp[2];

-  u8_t optdata[4];

-};

-

-/* The ICMP and IP headers. */

-struct uip_icmpip_hdr {

-#if UIP_CONF_IPV6

-  /* IPv6 header. */

-  u8_t vtc,

-    tcf;

-  u16_t flow;

-  u8_t len[2];

-  u8_t proto, ttl;

-  uip_ip6addr_t srcipaddr, destipaddr;

-#else /* UIP_CONF_IPV6 */

-  /* IPv4 header. */

-  u8_t vhl,

-    tos,

-    len[2],

-    ipid[2],

-    ipoffset[2],

-    ttl,

-    proto;

-  u16_t ipchksum;

-  uip_ipaddr_t srcipaddr, destipaddr;

-#endif /* UIP_CONF_IPV6 */

-  

-  /* ICMP header. */

-  u8_t type, icode;

-  u16_t icmpchksum;

-#if !UIP_CONF_IPV6

-  u16_t id, seqno;

-  u8_t payload[1];

-#endif /* !UIP_CONF_IPV6 */

-};

-

-

-/* The UDP and IP headers. */

-struct uip_udpip_hdr {

-#if UIP_CONF_IPV6

-  /* IPv6 header. */

-  u8_t vtc,

-    tcf;

-  u16_t flow;

-  u8_t len[2];

-  u8_t proto, ttl;

-  uip_ip6addr_t srcipaddr, destipaddr;

-#else /* UIP_CONF_IPV6 */

-  /* IP header. */

-  u8_t vhl,

-    tos,

-    len[2],

-    ipid[2],

-    ipoffset[2],

-    ttl,

-    proto;

-  u16_t ipchksum;

-  uip_ipaddr_t srcipaddr, destipaddr;

-#endif /* UIP_CONF_IPV6 */

-  

-  /* UDP header. */

-  u16_t srcport,

-    destport;

-  u16_t udplen;

-  u16_t udpchksum;

-};

-

-/*

- * In IPv6 the length of the L3 headers before the transport header is

- * not fixed, due to the possibility to include extension option headers

- * after the IP header. hence we split here L3 and L4 headers

- */

-/* The IP header */

-struct uip_ip_hdr {

-#if UIP_CONF_IPV6

-  /* IPV6 header */

-  u8_t vtc;

-  u8_t tcflow;

-  u16_t flow;

-  u8_t len[2];

-  u8_t proto, ttl;

-  uip_ip6addr_t srcipaddr, destipaddr;

-#else /* UIP_CONF_IPV6 */

-  /* IPV4 header */

-  u8_t vhl,

-    tos,

-    len[2],

-    ipid[2],

-    ipoffset[2],

-    ttl,

-    proto;

-  u16_t ipchksum;

-  uip_ipaddr_t srcipaddr, destipaddr;

-#endif /* UIP_CONF_IPV6 */

-};

-

-

-/*

- * IPv6 extension option headers: we are able to process

- * the 4 extension headers defined in RFC2460 (IPv6):

- * - Hop by hop option header, destination option header:

- *   These two are not used by any core IPv6 protocol, hence

- *   we just read them and go to the next. They convey options,

- *   the options defined in RFC2460 are Pad1 and PadN, which do

- *   some padding, and that we do not need to read (the length

- *   field in the header is enough)

- * - Routing header: this one is most notably used by MIPv6,

- *   which we do not implement, hence we just read it and go

- *   to the next

- * - Fragmentation header: we read this header and are able to

- *   reassemble packets

- *

- * We do not offer any means to send packets with extension headers

- *

- * We do not implement Authentication and ESP headers, which are

- * used in IPSec and defined in RFC4302,4303,4305,4385

- */

-/* common header part */

-struct uip_ext_hdr {

-  u8_t next;

-  u8_t len;

-};

-

-/* Hop by Hop option header */

-struct uip_hbho_hdr {

-  u8_t next;

-  u8_t len;

-};

-

-/* destination option header */

-struct uip_desto_hdr {

-  u8_t next;

-  u8_t len;

-};

-

-/* We do not define structures for PAD1 and PADN options */

-

-/*

- * routing header

- * the routing header as 4 common bytes, then routing header type

- * specific data there are several types of routing header. Type 0 was

- * deprecated as per RFC5095 most notable other type is 2, used in

- * RFC3775 (MIPv6) here we do not implement MIPv6, so we just need to

- * parse the 4 first bytes

- */

-struct uip_routing_hdr {

-  u8_t next;

-  u8_t len;

-  u8_t routing_type;

-  u8_t seg_left;

-};

-

-/* fragmentation header */

-struct uip_frag_hdr {

-  u8_t next;

-  u8_t res;

-  u16_t offsetresmore;

-  u32_t id;

-};

-

-/*

- * an option within the destination or hop by hop option headers

- * it contains type an length, which is true for all options but PAD1

- */

-struct uip_ext_hdr_opt {

-  u8_t type;

-  u8_t len;

-};

-

-/* PADN option */

-struct uip_ext_hdr_opt_padn {

-  u8_t opt_type;

-  u8_t opt_len;

-};

-

-/* TCP header */

-struct uip_tcp_hdr {

-  u16_t srcport;

-  u16_t destport;

-  u8_t seqno[4];

-  u8_t ackno[4];

-  u8_t tcpoffset;

-  u8_t flags;

-  u8_t  wnd[2];

-  u16_t tcpchksum;

-  u8_t urgp[2];

-  u8_t optdata[4];

-};

-

-/* The ICMP headers. */

-struct uip_icmp_hdr {

-  u8_t type, icode;

-  u16_t icmpchksum;

-#if !UIP_CONF_IPV6

-  u16_t id, seqno;

-#endif /* !UIP_CONF_IPV6 */

-};

-

-

-/* The UDP headers. */

-struct uip_udp_hdr {

-  u16_t srcport;

-  u16_t destport;

-  u16_t udplen;

-  u16_t udpchksum;

-};

-

-

-/**

- * The buffer size available for user data in the \ref uip_buf buffer.

- *

- * This macro holds the available size for user data in the \ref

- * uip_buf buffer. The macro is intended to be used for checking

- * bounds of available user data.

- *

- * Example:

- \code

- snprintf(uip_appdata, UIP_APPDATA_SIZE, "%u\n", i);

- \endcode

- *

- * \hideinitializer

- */

-#define UIP_APPDATA_SIZE (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)

-#define UIP_APPDATA_PTR (void *)&uip_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN]

-

-#define UIP_PROTO_ICMP  1

-#define UIP_PROTO_TCP   6

-#define UIP_PROTO_UDP   17

-#define UIP_PROTO_ICMP6 58

-

-

-#if UIP_CONF_IPV6

-/** @{ */

-/** \brief  extension headers types */

-#define UIP_PROTO_HBHO        0

-#define UIP_PROTO_DESTO       60

-#define UIP_PROTO_ROUTING     43

-#define UIP_PROTO_FRAG        44

-#define UIP_PROTO_NONE        59

-/** @} */

-

-/** @{ */

-/** \brief  Destination and Hop By Hop extension headers option types */

-#define UIP_EXT_HDR_OPT_PAD1  0

-#define UIP_EXT_HDR_OPT_PADN  1

-/** @} */

-

-/** @{ */

-/**

- * \brief Bitmaps for extension header processing

- *

- * When processing extension headers, we should record somehow which one we

- * see, because you cannot have twice the same header, except for destination

- * We store all this in one u8_t bitmap one bit for each header expected. The

- * order in the bitmap is the order recommended in RFC2460

- */

-#define UIP_EXT_HDR_BITMAP_HBHO 0x01

-#define UIP_EXT_HDR_BITMAP_DESTO1 0x02

-#define UIP_EXT_HDR_BITMAP_ROUTING 0x04

-#define UIP_EXT_HDR_BITMAP_FRAG 0x08

-#define UIP_EXT_HDR_BITMAP_AH 0x10

-#define UIP_EXT_HDR_BITMAP_ESP 0x20

-#define UIP_EXT_HDR_BITMAP_DESTO2 0x40

-/** @} */

-

-

-#endif /* UIP_CONF_IPV6 */

-

-

-/* Header sizes. */

-#if UIP_CONF_IPV6

-#define UIP_IPH_LEN    40

-#define UIP_FRAGH_LEN  8

-#else /* UIP_CONF_IPV6 */

-#define UIP_IPH_LEN    20    /* Size of IP header */

-#endif /* UIP_CONF_IPV6 */

-

-#define UIP_UDPH_LEN    8    /* Size of UDP header */

-#define UIP_TCPH_LEN   20    /* Size of TCP header */

-#ifdef UIP_IPH_LEN

-#define UIP_ICMPH_LEN   4    /* Size of ICMP header */

-#endif

-#define UIP_IPUDPH_LEN (UIP_UDPH_LEN + UIP_IPH_LEN)    /* Size of IP +

-                        * UDP

-							   * header */

-#define UIP_IPTCPH_LEN (UIP_TCPH_LEN + UIP_IPH_LEN)    /* Size of IP +

-							   * TCP

-							   * header */

-#define UIP_TCPIP_HLEN UIP_IPTCPH_LEN

-#define UIP_IPICMPH_LEN (UIP_IPH_LEN + UIP_ICMPH_LEN) /* size of ICMP

-                                                         + IP header */

-#define UIP_LLIPH_LEN (UIP_LLH_LEN + UIP_IPH_LEN)    /* size of L2

-                                                        + IP header */

-#if UIP_CONF_IPV6

-/**

- * The sums below are quite used in ND. When used for uip_buf, we

- * include link layer length when used for uip_len, we do not, hence

- * we need values with and without LLH_LEN we do not use capital

- * letters as these values are variable

- */

-#define uip_l2_l3_hdr_len (UIP_LLH_LEN + UIP_IPH_LEN + uip_ext_len)

-#define uip_l2_l3_icmp_hdr_len (UIP_LLH_LEN + UIP_IPH_LEN + uip_ext_len + UIP_ICMPH_LEN)

-#define uip_l3_hdr_len (UIP_IPH_LEN + uip_ext_len)

-#define uip_l3_icmp_hdr_len (UIP_IPH_LEN + uip_ext_len + UIP_ICMPH_LEN)

-#endif /*UIP_CONF_IPV6*/

-

-

-#if UIP_FIXEDADDR

-extern const uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;

-#else /* UIP_FIXEDADDR */

-extern uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;

-#endif /* UIP_FIXEDADDR */

-extern const uip_ipaddr_t uip_broadcast_addr;

-extern const uip_ipaddr_t uip_all_zeroes_addr;

-

-#if UIP_FIXEDETHADDR

-extern const uip_lladdr_t uip_lladdr;

-#else

-extern uip_lladdr_t uip_lladdr;

-#endif

-

-

-

-

-#ifdef UIP_CONF_IPV6

-/**

- * \brief Is IPv6 address a the unspecified address

- * a is of type uip_ipaddr_t

- */

-#define uip_is_addr_unspecified(a)               \

-  ((((a)->u16[0]) == 0) &&                       \

-   (((a)->u16[1]) == 0) &&                       \

-   (((a)->u16[2]) == 0) &&                       \

-   (((a)->u16[3]) == 0) &&                       \

-   (((a)->u16[4]) == 0) &&                       \

-   (((a)->u16[5]) == 0) &&                       \

-   (((a)->u16[6]) == 0) &&                       \

-   (((a)->u16[7]) == 0))

-

-/** \brief Is IPv6 address a the link local all-nodes multicast address */

-#define uip_is_addr_linklocal_allnodes_mcast(a)     \

-  ((((a)->u8[0]) == 0xff) &&                        \

-   (((a)->u8[1]) == 0x02) &&                        \

-   (((a)->u16[1]) == 0) &&                          \

-   (((a)->u16[2]) == 0) &&                          \

-   (((a)->u16[3]) == 0) &&                          \

-   (((a)->u16[4]) == 0) &&                          \

-   (((a)->u16[5]) == 0) &&                          \

-   (((a)->u16[6]) == 0) &&                          \

-   (((a)->u8[14]) == 0) &&                          \

-   (((a)->u8[15]) == 0x01))

-

-/** \brief set IP address a to unspecified */

-#define uip_create_unspecified(a) uip_ip6addr(a, 0, 0, 0, 0, 0, 0, 0, 0)

-

-/** \brief set IP address a to the link local all-nodes multicast address */

-#define uip_create_linklocal_allnodes_mcast(a) uip_ip6addr(a, 0xff02, 0, 0, 0, 0, 0, 0, 0x0001)

-

-/** \brief set IP address a to the link local all-routers multicast address */

-#define uip_create_linklocal_allrouters_mcast(a) uip_ip6addr(a, 0xff02, 0, 0, 0, 0, 0, 0, 0x0002)

-

-/**

- * \brief  is addr (a) a solicited node multicast address, see RFC3513

- *  a is of type uip_ipaddr_t*

- */

-#define uip_is_addr_solicited_node(a)           \

-  ((((a)->u8[0]) == 0xFF) &&                     \

-  (((a)->u8[1]) == 0x02) &&                     \

-  (((a)->u16[1]) == 0) &&                       \

-  (((a)->u16[2]) == 0) &&                       \

-  (((a)->u16[3]) == 0) &&                       \

-  (((a)->u16[4]) == 0) &&                       \

-  (((a)->u16[5]) == 1) &&                       \

-  (((a)->u8[12]) == 0xFF))

-

-/**

- * \briefput in b the solicited node address corresponding to address a

- * both a and b are of type uip_ipaddr_t*

- * */

-#define uip_create_solicited_node(a, b)    \

-  (((b)->u8[0]) = 0xFF);                        \

-  (((b)->u8[1]) = 0x02);                        \

-  (((b)->u16[1]) = 0);                          \

-  (((b)->u16[2]) = 0);                          \

-  (((b)->u16[3]) = 0);                          \

-  (((b)->u16[4]) = 0);                          \

-  (((b)->u8[10]) = 0);                          \

-  (((b)->u8[11]) = 0x01);                       \

-  (((b)->u8[12]) = 0xFF);                       \

-  (((b)->u8[13]) = ((a)->u8[13]));              \

-  (((b)->u16[7]) = ((a)->u16[7]))

-

-/**

- * \brief is addr (a) a link local unicast address, see RFC3513

- *  i.e. is (a) on prefix FE80::/10

- *  a is of type uip_ipaddr_t*

- */

-#define uip_is_addr_link_local(a) \

-  ((((a)->u8[0]) == 0xFE) && \

-  (((a)->u8[1]) == 0x80))

-

-/**

- * \brief was addr (a) forged based on the mac address m

- * a type is uip_ipaddr_t

- * m type is uiplladdr_t

- */

-#if UIP_CONF_LL_802154

-#define uip_is_addr_mac_addr_based(a, m) \

-  ((((a)->u8[8])  == (((m)->addr[0]) ^ 0x02)) &&   \

-   (((a)->u8[9])  == (m)->addr[1]) &&            \

-   (((a)->u8[10]) == (m)->addr[2]) &&            \

-   (((a)->u8[11]) == (m)->addr[3]) &&            \

-   (((a)->u8[12]) == (m)->addr[4]) &&            \

-   (((a)->u8[13]) == (m)->addr[5]) &&            \

-   (((a)->u8[14]) == (m)->addr[6]) &&            \

-   (((a)->u8[15]) == (m)->addr[7]))

-#else

-

-#define uip_is_addr_mac_addr_based(a, m) \

-  ((((a)->u8[8])  == (((m)->addr[0]) | 0x02)) &&   \

-   (((a)->u8[9])  == (m)->addr[1]) &&            \

-   (((a)->u8[10]) == (m)->addr[2]) &&            \

-   (((a)->u8[11]) == 0xff) &&            \

-   (((a)->u8[12]) == 0xfe) &&            \

-   (((a)->u8[13]) == (m)->addr[3]) &&            \

-   (((a)->u8[14]) == (m)->addr[4]) &&            \

-   (((a)->u8[15]) == (m)->addr[5]))

-   

-#endif /*UIP_CONF_LL_802154*/

-

-/**

- * \brief is address a multicast address, see RFC 3513

- * a is of type uip_ipaddr_t*

- * */

-#define uip_is_addr_mcast(a)                    \

-  (((a)->u8[0]) == 0xFF)

-

-/**

- * \brief is group-id of multicast address a

- * the all nodes group-id

- */

-#define uip_is_mcast_group_id_all_nodes(a) \

-  ((((a)->u16[1])  == 0) &&                 \

-   (((a)->u16[2])  == 0) &&                 \

-   (((a)->u16[3])  == 0) &&                 \

-   (((a)->u16[4])  == 0) &&                 \

-   (((a)->u16[5])  == 0) &&                 \

-   (((a)->u16[6])  == 0) &&                 \

-   (((a)->u8[14])  == 0) &&                 \

-   (((a)->u8[15])  == 1))

-

-/**

- * \brief is group-id of multicast address a

- * the all routers group-id

- */

-#define uip_is_mcast_group_id_all_routers(a) \

-  ((((a)->u16[1])  == 0) &&                 \

-   (((a)->u16[2])  == 0) &&                 \

-   (((a)->u16[3])  == 0) &&                 \

-   (((a)->u16[4])  == 0) &&                 \

-   (((a)->u16[5])  == 0) &&                 \

-   (((a)->u16[6])  == 0) &&                 \

-   (((a)->u8[14])  == 0) &&                 \

-   (((a)->u8[15])  == 2))

-

-

-#endif /*UIP_CONF_IPV6*/

-

-/**

- * Calculate the Internet checksum over a buffer.

- *

- * The Internet checksum is the one's complement of the one's

- * complement sum of all 16-bit words in the buffer.

- *

- * See RFC1071.

- *

- * \param buf A pointer to the buffer over which the checksum is to be

- * computed.

- *

- * \param len The length of the buffer over which the checksum is to

- * be computed.

- *

- * \return The Internet checksum of the buffer.

- */

-u16_t uip_chksum(u16_t *buf, u16_t len);

-

-/**

- * Calculate the IP header checksum of the packet header in uip_buf.

- *

- * The IP header checksum is the Internet checksum of the 20 bytes of

- * the IP header.

- *

- * \return The IP header checksum of the IP header in the uip_buf

- * buffer.

- */

-u16_t uip_ipchksum(void);

-

-/**

- * Calculate the TCP checksum of the packet in uip_buf and uip_appdata.

- *

- * The TCP checksum is the Internet checksum of data contents of the

- * TCP segment, and a pseudo-header as defined in RFC793.

- *

- * \return The TCP checksum of the TCP segment in uip_buf and pointed

- * to by uip_appdata.

- */

-u16_t uip_tcpchksum(void);

-

-/**

- * Calculate the UDP checksum of the packet in uip_buf and uip_appdata.

- *

- * The UDP checksum is the Internet checksum of data contents of the

- * UDP segment, and a pseudo-header as defined in RFC768.

- *

- * \return The UDP checksum of the UDP segment in uip_buf and pointed

- * to by uip_appdata.

- */

-u16_t uip_udpchksum(void);

-

-/**

- * Calculate the ICMP checksum of the packet in uip_buf.

- *

- * \return The ICMP checksum of the ICMP packet in uip_buf

- */

-u16_t uip_icmp6chksum(void);

-

-

-#endif /* __UIP_H__ */

-

-

-/** @} */

+
+/**
+ * \addtogroup uip
+ * @{
+ */
+
+/**
+ * \file
+ * Header file for the uIP TCP/IP stack.
+ * \author  Adam Dunkels <adam@dunkels.com>
+ * \author  Julien Abeille <jabeille@cisco.com> (IPv6 related code)
+ * \author  Mathilde Durvy <mdurvy@cisco.com> (IPv6 related code)
+ *
+ * The uIP TCP/IP stack header file contains definitions for a number
+ * of C macros that are used by uIP programs as well as internal uIP
+ * structures, TCP/IP header structures and function declarations.
+ *
+ */
+
+/*
+ * Copyright (c) 2001-2003, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uip.h,v 1.24 2009/04/06 13:18:50 nvt-se Exp $
+ *
+ */
+
+#ifndef __UIP_H__
+#define __UIP_H__
+
+#include "uipopt.h"
+
+/**
+ * Representation of an IP address.
+ *
+ */
+#if UIP_CONF_IPV6
+typedef union uip_ip6addr_t {
+  u8_t  u8[16];			/* Initializer, must come first!!! */
+  u16_t u16[8];
+} uip_ip6addr_t;
+
+typedef uip_ip6addr_t uip_ipaddr_t;
+#else /* UIP_CONF_IPV6 */
+typedef union uip_ip4addr_t {
+  u8_t  u8[4];			/* Initializer, must come first!!! */
+  u16_t u16[2];
+#if 0
+  u32_t u32;
+#endif
+} uip_ip4addr_t;
+typedef uip_ip4addr_t uip_ipaddr_t;
+#endif /* UIP_CONF_IPV6 */
+
+
+/*---------------------------------------------------------------------------*/
+
+/** \brief 16 bit 802.15.4 address */
+struct uip_802154_shortaddr {
+  u8_t addr[2];
+};
+/** \brief 64 bit 802.15.4 address */
+struct uip_802154_longaddr {
+  u8_t addr[8];
+};
+
+/** \brief 802.11 address */
+struct uip_80211_addr {
+  u8_t addr[6];
+};
+
+/** \brief 802.3 address */
+struct uip_eth_addr {
+  u8_t addr[6];
+};
+
+#if UIP_CONF_LL_802154
+/** \brief 802.15.4 address */
+typedef struct uip_802154_longaddr uip_lladdr_t;
+#define UIP_802154_SHORTADDR_LEN 2
+#define UIP_802154_LONGADDR_LEN  8
+#define UIP_LLADDR_LEN UIP_802154_LONGADDR_LEN
+#else /*UIP_CONF_LL_802154*/
+#if UIP_CONF_LL_80211
+/** \brief 802.11 address */
+typedef struct uip_80211_addr uip_lladdr_t;
+#define UIP_LLADDR_LEN 6
+#else /*UIP_CONF_LL_80211*/
+/** \brief Ethernet address */
+typedef struct uip_eth_addr uip_lladdr_t;
+#define UIP_LLADDR_LEN 6
+#endif /*UIP_CONF_LL_80211*/
+#endif /*UIP_CONF_LL_802154*/
+
+/*---------------------------------------------------------------------------*/
+/* First, the functions that should be called from the
+ * system. Initialization, the periodic timer, and incoming packets are
+ * handled by the following three functions.
+ */
+/**
+ * \defgroup uipconffunc uIP configuration functions
+ * @{
+ *
+ * The uIP configuration functions are used for setting run-time
+ * parameters in uIP such as IP addresses.
+ */
+
+/**
+ * Set the IP address of this host.
+ *
+ * The IP address is represented as a 4-byte array where the first
+ * octet of the IP address is put in the first member of the 4-byte
+ * array.
+ *
+ * Example:
+ \code
+
+ uip_ipaddr_t addr;
+
+ uip_ipaddr(&addr, 192,168,1,2);
+ uip_sethostaddr(&addr);
+ 
+ \endcode
+ * \param addr A pointer to an IP address of type uip_ipaddr_t;
+ *
+ * \sa uip_ipaddr()
+ *
+ * \hideinitializer
+ */
+#define uip_sethostaddr(addr) uip_ipaddr_copy(&uip_hostaddr, (addr))
+
+/**
+ * Get the IP address of this host.
+ *
+ * The IP address is represented as a 4-byte array where the first
+ * octet of the IP address is put in the first member of the 4-byte
+ * array.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t hostaddr;
+
+ uip_gethostaddr(&hostaddr);
+ \endcode
+ * \param addr A pointer to a uip_ipaddr_t variable that will be
+ * filled in with the currently configured IP address.
+ *
+ * \hideinitializer
+ */
+#define uip_gethostaddr(addr) uip_ipaddr_copy((addr), &uip_hostaddr)
+
+/**
+ * Set the default router's IP address.
+ *
+ * \param addr A pointer to a uip_ipaddr_t variable containing the IP
+ * address of the default router.
+ *
+ * \sa uip_ipaddr()
+ *
+ * \hideinitializer
+ */
+#define uip_setdraddr(addr) uip_ipaddr_copy(&uip_draddr, (addr))
+
+/**
+ * Set the netmask.
+ *
+ * \param addr A pointer to a uip_ipaddr_t variable containing the IP
+ * address of the netmask.
+ *
+ * \sa uip_ipaddr()
+ *
+ * \hideinitializer
+ */
+#define uip_setnetmask(addr) uip_ipaddr_copy(&uip_netmask, (addr))
+
+
+/**
+ * Get the default router's IP address.
+ *
+ * \param addr A pointer to a uip_ipaddr_t variable that will be
+ * filled in with the IP address of the default router.
+ *
+ * \hideinitializer
+ */
+#define uip_getdraddr(addr) uip_ipaddr_copy((addr), &uip_draddr)
+
+/**
+ * Get the netmask.
+ *
+ * \param addr A pointer to a uip_ipaddr_t variable that will be
+ * filled in with the value of the netmask.
+ *
+ * \hideinitializer
+ */
+#define uip_getnetmask(addr) uip_ipaddr_copy((addr), &uip_netmask)
+
+/** @} */
+
+/**
+ * \defgroup uipinit uIP initialization functions
+ * @{
+ *
+ * The uIP initialization functions are used for booting uIP.
+ */
+
+/**
+ * uIP initialization function.
+ *
+ * This function should be called at boot up to initilize the uIP
+ * TCP/IP stack.
+ */
+void uip_init(void);
+
+/**
+ * uIP initialization function.
+ *
+ * This function may be used at boot time to set the initial ip_id.
+ */
+void uip_setipid(u16_t id);
+
+/** @} */
+
+/**
+ * \defgroup uipdevfunc uIP device driver functions
+ * @{
+ *
+ * These functions are used by a network device driver for interacting
+ * with uIP.
+ */
+
+/**
+ * Process an incoming packet.
+ *
+ * This function should be called when the device driver has received
+ * a packet from the network. The packet from the device driver must
+ * be present in the uip_buf buffer, and the length of the packet
+ * should be placed in the uip_len variable.
+ *
+ * When the function returns, there may be an outbound packet placed
+ * in the uip_buf packet buffer. If so, the uip_len variable is set to
+ * the length of the packet. If no packet is to be sent out, the
+ * uip_len variable is set to 0.
+ *
+ * The usual way of calling the function is presented by the source
+ * code below.
+ \code
+ uip_len = devicedriver_poll();
+ if(uip_len > 0) {
+ uip_input();
+ if(uip_len > 0) {
+ devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \note If you are writing a uIP device driver that needs ARP
+ * (Address Resolution Protocol), e.g., when running uIP over
+ * Ethernet, you will need to call the uIP ARP code before calling
+ * this function:
+ \code
+ #define BUF ((struct uip_eth_hdr *)&uip_buf[0])
+ uip_len = ethernet_devicedrver_poll();
+ if(uip_len > 0) {
+ if(BUF->type == HTONS(UIP_ETHTYPE_IP)) {
+ uip_arp_ipin();
+ uip_input();
+ if(uip_len > 0) {
+ uip_arp_out();
+ ethernet_devicedriver_send();
+ }
+ } else if(BUF->type == HTONS(UIP_ETHTYPE_ARP)) {
+ uip_arp_arpin();
+ if(uip_len > 0) {
+ ethernet_devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \hideinitializer
+ */
+#define uip_input()        uip_process(UIP_DATA)
+
+
+/**
+ * Periodic processing for a connection identified by its number.
+ *
+ * This function does the necessary periodic processing (timers,
+ * polling) for a uIP TCP conneciton, and should be called when the
+ * periodic uIP timer goes off. It should be called for every
+ * connection, regardless of whether they are open of closed.
+ *
+ * When the function returns, it may have an outbound packet waiting
+ * for service in the uIP packet buffer, and if so the uip_len
+ * variable is set to a value larger than zero. The device driver
+ * should be called to send out the packet.
+ *
+ * The usual way of calling the function is through a for() loop like
+ * this:
+ \code
+ for(i = 0; i < UIP_CONNS; ++i) {
+ uip_periodic(i);
+ if(uip_len > 0) {
+ devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \note If you are writing a uIP device driver that needs ARP
+ * (Address Resolution Protocol), e.g., when running uIP over
+ * Ethernet, you will need to call the uip_arp_out() function before
+ * calling the device driver:
+ \code
+ for(i = 0; i < UIP_CONNS; ++i) {
+ uip_periodic(i);
+ if(uip_len > 0) {
+ uip_arp_out();
+ ethernet_devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \param conn The number of the connection which is to be periodically polled.
+ *
+ * \hideinitializer
+ */
+#if UIP_TCP
+#define uip_periodic(conn) do { uip_conn = &uip_conns[conn];    \
+    uip_process(UIP_TIMER); } while (0)
+
+/**
+ *
+ *
+ */
+#define uip_conn_active(conn) (uip_conns[conn].tcpstateflags != UIP_CLOSED)
+
+/**
+ * Perform periodic processing for a connection identified by a pointer
+ * to its structure.
+ *
+ * Same as uip_periodic() but takes a pointer to the actual uip_conn
+ * struct instead of an integer as its argument. This function can be
+ * used to force periodic processing of a specific connection.
+ *
+ * \param conn A pointer to the uip_conn struct for the connection to
+ * be processed.
+ *
+ * \hideinitializer
+ */
+#define uip_periodic_conn(conn) do { uip_conn = conn;   \
+    uip_process(UIP_TIMER); } while (0)
+
+/**
+ * Request that a particular connection should be polled.
+ *
+ * Similar to uip_periodic_conn() but does not perform any timer
+ * processing. The application is polled for new data.
+ *
+ * \param conn A pointer to the uip_conn struct for the connection to
+ * be processed.
+ *
+ * \hideinitializer
+ */
+#define uip_poll_conn(conn) do { uip_conn = conn;       \
+    uip_process(UIP_POLL_REQUEST); } while (0)
+
+#endif /* UIP_TCP */
+
+#if UIP_UDP
+/**
+ * Periodic processing for a UDP connection identified by its number.
+ *
+ * This function is essentially the same as uip_periodic(), but for
+ * UDP connections. It is called in a similar fashion as the
+ * uip_periodic() function:
+ \code
+ for(i = 0; i < UIP_UDP_CONNS; i++) {
+ uip_udp_periodic(i);
+ if(uip_len > 0) {
+ devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \note As for the uip_periodic() function, special care has to be
+ * taken when using uIP together with ARP and Ethernet:
+ \code
+ for(i = 0; i < UIP_UDP_CONNS; i++) {
+ uip_udp_periodic(i);
+ if(uip_len > 0) {
+ uip_arp_out();
+ ethernet_devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \param conn The number of the UDP connection to be processed.
+ *
+ * \hideinitializer
+ */
+#define uip_udp_periodic(conn) do { uip_udp_conn = &uip_udp_conns[conn]; \
+    uip_process(UIP_UDP_TIMER); } while(0)
+
+/**
+ * Periodic processing for a UDP connection identified by a pointer to
+ * its structure.
+ *
+ * Same as uip_udp_periodic() but takes a pointer to the actual
+ * uip_conn struct instead of an integer as its argument. This
+ * function can be used to force periodic processing of a specific
+ * connection.
+ *
+ * \param conn A pointer to the uip_udp_conn struct for the connection
+ * to be processed.
+ *
+ * \hideinitializer
+ */
+#define uip_udp_periodic_conn(conn) do { uip_udp_conn = conn;   \
+    uip_process(UIP_UDP_TIMER); } while(0)
+#endif /* UIP_UDP */
+
+/** \brief Abandon the reassembly of the current packet */
+void uip_reass_over(void);
+
+/**
+ * The uIP packet buffer.
+ *
+ * The uip_buf array is used to hold incoming and outgoing
+ * packets. The device driver should place incoming data into this
+ * buffer. When sending data, the device driver should read the link
+ * level headers and the TCP/IP headers from this buffer. The size of
+ * the link level headers is configured by the UIP_LLH_LEN define.
+ *
+ * \note The application data need not be placed in this buffer, so
+ * the device driver must read it from the place pointed to by the
+ * uip_appdata pointer as illustrated by the following example:
+ \code
+ void
+ devicedriver_send(void)
+ {
+ hwsend(&uip_buf[0], UIP_LLH_LEN);
+ if(uip_len <= UIP_LLH_LEN + UIP_TCPIP_HLEN) {
+ hwsend(&uip_buf[UIP_LLH_LEN], uip_len - UIP_LLH_LEN);
+ } else {
+ hwsend(&uip_buf[UIP_LLH_LEN], UIP_TCPIP_HLEN);
+ hwsend(uip_appdata, uip_len - UIP_TCPIP_HLEN - UIP_LLH_LEN);
+ }
+ }
+ \endcode
+*/
+extern u8_t uip_buf[UIP_BUFSIZE+2];
+
+
+
+/** @} */
+
+/*---------------------------------------------------------------------------*/
+/* Functions that are used by the uIP application program. Opening and
+ * closing connections, sending and receiving data, etc. is all
+ * handled by the functions below.
+ */
+/**
+ * \defgroup uipappfunc uIP application functions
+ * @{
+ *
+ * Functions used by an application running of top of uIP.
+ */
+
+/**
+ * Start listening to the specified port.
+ *
+ * \note Since this function expects the port number in network byte
+ * order, a conversion using HTONS() or htons() is necessary.
+ *
+ \code
+ uip_listen(HTONS(80));
+ \endcode
+ *
+ * \param port A 16-bit port number in network byte order.
+ */
+void uip_listen(u16_t port);
+
+/**
+ * Stop listening to the specified port.
+ *
+ * \note Since this function expects the port number in network byte
+ * order, a conversion using HTONS() or htons() is necessary.
+ *
+ \code
+ uip_unlisten(HTONS(80));
+ \endcode
+ *
+ * \param port A 16-bit port number in network byte order.
+ */
+void uip_unlisten(u16_t port);
+
+/**
+ * Connect to a remote host using TCP.
+ *
+ * This function is used to start a new connection to the specified
+ * port on the specified host. It allocates a new connection identifier,
+ * sets the connection to the SYN_SENT state and sets the
+ * retransmission timer to 0. This will cause a TCP SYN segment to be
+ * sent out the next time this connection is periodically processed,
+ * which usually is done within 0.5 seconds after the call to
+ * uip_connect().
+ *
+ * \note This function is available only if support for active open
+ * has been configured by defining UIP_ACTIVE_OPEN to 1 in uipopt.h.
+ *
+ * \note Since this function requires the port number to be in network
+ * byte order, a conversion using HTONS() or htons() is necessary.
+ *
+ \code
+ uip_ipaddr_t ipaddr;
+
+ uip_ipaddr(&ipaddr, 192,168,1,2);
+ uip_connect(&ipaddr, HTONS(80));
+ \endcode
+ *
+ * \param ripaddr The IP address of the remote host.
+ *
+ * \param port A 16-bit port number in network byte order.
+ *
+ * \return A pointer to the uIP connection identifier for the new connection,
+ * or NULL if no connection could be allocated.
+ *
+ */
+struct uip_conn *uip_connect(uip_ipaddr_t *ripaddr, u16_t port);
+
+
+
+/**
+ * \internal
+ *
+ * Check if a connection has outstanding (i.e., unacknowledged) data.
+ *
+ * \param conn A pointer to the uip_conn structure for the connection.
+ *
+ * \hideinitializer
+ */
+#define uip_outstanding(conn) ((conn)->len)
+
+/**
+ * Send data on the current connection.
+ *
+ * This function is used to send out a single segment of TCP
+ * data. Only applications that have been invoked by uIP for event
+ * processing can send data.
+ *
+ * The amount of data that actually is sent out after a call to this
+ * function is determined by the maximum amount of data TCP allows. uIP
+ * will automatically crop the data so that only the appropriate
+ * amount of data is sent. The function uip_mss() can be used to query
+ * uIP for the amount of data that actually will be sent.
+ *
+ * \note This function does not guarantee that the sent data will
+ * arrive at the destination. If the data is lost in the network, the
+ * application will be invoked with the uip_rexmit() event being
+ * set. The application will then have to resend the data using this
+ * function.
+ *
+ * \param data A pointer to the data which is to be sent.
+ *
+ * \param len The maximum amount of data bytes to be sent.
+ *
+ * \hideinitializer
+ */
+void uip_send(const void *data, int len);
+
+/**
+ * The length of any incoming data that is currently available (if available)
+ * in the uip_appdata buffer.
+ *
+ * The test function uip_data() must first be used to check if there
+ * is any data available at all.
+ *
+ * \hideinitializer
+ */
+/*void uip_datalen(void);*/
+#define uip_datalen()       uip_len
+
+/**
+ * The length of any out-of-band data (urgent data) that has arrived
+ * on the connection.
+ *
+ * \note The configuration parameter UIP_URGDATA must be set for this
+ * function to be enabled.
+ *
+ * \hideinitializer
+ */
+#define uip_urgdatalen()    uip_urglen
+
+/**
+ * Close the current connection.
+ *
+ * This function will close the current connection in a nice way.
+ *
+ * \hideinitializer
+ */
+#define uip_close()         (uip_flags = UIP_CLOSE)
+
+/**
+ * Abort the current connection.
+ *
+ * This function will abort (reset) the current connection, and is
+ * usually used when an error has occurred that prevents using the
+ * uip_close() function.
+ *
+ * \hideinitializer
+ */
+#define uip_abort()         (uip_flags = UIP_ABORT)
+
+/**
+ * Tell the sending host to stop sending data.
+ *
+ * This function will close our receiver's window so that we stop
+ * receiving data for the current connection.
+ *
+ * \hideinitializer
+ */
+#define uip_stop()          (uip_conn->tcpstateflags |= UIP_STOPPED)
+
+/**
+ * Find out if the current connection has been previously stopped with
+ * uip_stop().
+ *
+ * \hideinitializer
+ */
+#define uip_stopped(conn)   ((conn)->tcpstateflags & UIP_STOPPED)
+
+/**
+ * Restart the current connection, if is has previously been stopped
+ * with uip_stop().
+ *
+ * This function will open the receiver's window again so that we
+ * start receiving data for the current connection.
+ *
+ * \hideinitializer
+ */
+#define uip_restart()         do { uip_flags |= UIP_NEWDATA;    \
+    uip_conn->tcpstateflags &= ~UIP_STOPPED;                    \
+  } while(0)
+
+
+/* uIP tests that can be made to determine in what state the current
+   connection is, and what the application function should do. */
+
+/**
+ * Is the current connection a UDP connection?
+ *
+ * This function checks whether the current connection is a UDP connection.
+ *
+ * \hideinitializer
+ *
+ */
+#define uip_udpconnection() (uip_conn == NULL)
+
+/**
+ * Is new incoming data available?
+ *
+ * Will reduce to non-zero if there is new data for the application
+ * present at the uip_appdata pointer. The size of the data is
+ * available through the uip_len variable.
+ *
+ * \hideinitializer
+ */
+#define uip_newdata()   (uip_flags & UIP_NEWDATA)
+
+/**
+ * Has previously sent data been acknowledged?
+ *
+ * Will reduce to non-zero if the previously sent data has been
+ * acknowledged by the remote host. This means that the application
+ * can send new data.
+ *
+ * \hideinitializer
+ */
+#define uip_acked()   (uip_flags & UIP_ACKDATA)
+
+/**
+ * Has the connection just been connected?
+ *
+ * Reduces to non-zero if the current connection has been connected to
+ * a remote host. This will happen both if the connection has been
+ * actively opened (with uip_connect()) or passively opened (with
+ * uip_listen()).
+ *
+ * \hideinitializer
+ */
+#define uip_connected() (uip_flags & UIP_CONNECTED)
+
+/**
+ * Has the connection been closed by the other end?
+ *
+ * Is non-zero if the connection has been closed by the remote
+ * host. The application may then do the necessary clean-ups.
+ *
+ * \hideinitializer
+ */
+#define uip_closed()    (uip_flags & UIP_CLOSE)
+
+/**
+ * Has the connection been aborted by the other end?
+ *
+ * Non-zero if the current connection has been aborted (reset) by the
+ * remote host.
+ *
+ * \hideinitializer
+ */
+#define uip_aborted()    (uip_flags & UIP_ABORT)
+
+/**
+ * Has the connection timed out?
+ *
+ * Non-zero if the current connection has been aborted due to too many
+ * retransmissions.
+ *
+ * \hideinitializer
+ */
+#define uip_timedout()    (uip_flags & UIP_TIMEDOUT)
+
+/**
+ * Do we need to retransmit previously data?
+ *
+ * Reduces to non-zero if the previously sent data has been lost in
+ * the network, and the application should retransmit it. The
+ * application should send the exact same data as it did the last
+ * time, using the uip_send() function.
+ *
+ * \hideinitializer
+ */
+#define uip_rexmit()     (uip_flags & UIP_REXMIT)
+
+/**
+ * Is the connection being polled by uIP?
+ *
+ * Is non-zero if the reason the application is invoked is that the
+ * current connection has been idle for a while and should be
+ * polled.
+ *
+ * The polling event can be used for sending data without having to
+ * wait for the remote host to send data.
+ *
+ * \hideinitializer
+ */
+#define uip_poll()       (uip_flags & UIP_POLL)
+
+/**
+ * Get the initial maximum segment size (MSS) of the current
+ * connection.
+ *
+ * \hideinitializer
+ */
+#define uip_initialmss()             (uip_conn->initialmss)
+
+/**
+ * Get the current maximum segment size that can be sent on the current
+ * connection.
+ *
+ * The current maximum segment size that can be sent on the
+ * connection is computed from the receiver's window and the MSS of
+ * the connection (which also is available by calling
+ * uip_initialmss()).
+ *
+ * \hideinitializer
+ */
+#define uip_mss()             (uip_conn->mss)
+
+/**
+ * Set up a new UDP connection.
+ *
+ * This function sets up a new UDP connection. The function will
+ * automatically allocate an unused local port for the new
+ * connection. However, another port can be chosen by using the
+ * uip_udp_bind() call, after the uip_udp_new() function has been
+ * called.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t addr;
+ struct uip_udp_conn *c;
+ 
+ uip_ipaddr(&addr, 192,168,2,1);
+ c = uip_udp_new(&addr, HTONS(12345));
+ if(c != NULL) {
+ uip_udp_bind(c, HTONS(12344));
+ }
+ \endcode
+ * \param ripaddr The IP address of the remote host.
+ *
+ * \param rport The remote port number in network byte order.
+ *
+ * \return The uip_udp_conn structure for the new connection or NULL
+ * if no connection could be allocated.
+ */
+struct uip_udp_conn *uip_udp_new(const uip_ipaddr_t *ripaddr, u16_t rport);
+
+/**
+ * Removed a UDP connection.
+ *
+ * \param conn A pointer to the uip_udp_conn structure for the connection.
+ *
+ * \hideinitializer
+ */
+#define uip_udp_remove(conn) (conn)->lport = 0
+
+/**
+ * Bind a UDP connection to a local port.
+ *
+ * \param conn A pointer to the uip_udp_conn structure for the
+ * connection.
+ *
+ * \param port The local port number, in network byte order.
+ *
+ * \hideinitializer
+ */
+#define uip_udp_bind(conn, port) (conn)->lport = port
+
+/**
+ * Send a UDP datagram of length len on the current connection.
+ *
+ * This function can only be called in response to a UDP event (poll
+ * or newdata). The data must be present in the uip_buf buffer, at the
+ * place pointed to by the uip_appdata pointer.
+ *
+ * \param len The length of the data in the uip_buf buffer.
+ *
+ * \hideinitializer
+ */
+#define uip_udp_send(len) uip_send((char *)uip_appdata, len)
+
+/** @} */
+
+/* uIP convenience and converting functions. */
+
+/**
+ * \defgroup uipconvfunc uIP conversion functions
+ * @{
+ *
+ * These functions can be used for converting between different data
+ * formats used by uIP.
+ */
+ 
+/**
+ * Convert an IP address to four bytes separated by commas.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ printf("ipaddr=%d.%d.%d.%d\n", uip_ipaddr_to_quad(&ipaddr));
+ \endcode
+ *
+ * \param a A pointer to a uip_ipaddr_t.
+ * \hideinitializer
+ */
+#define uip_ipaddr_to_quad(a) (a)->u8[0],(a)->u8[1],(a)->u8[2],(a)->u8[3]
+
+/**
+ * Construct an IP address from four bytes.
+ *
+ * This function constructs an IP address of the type that uIP handles
+ * internally from four bytes. The function is handy for specifying IP
+ * addresses to use with e.g. the uip_connect() function.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ struct uip_conn *c;
+ 
+ uip_ipaddr(&ipaddr, 192,168,1,2);
+ c = uip_connect(&ipaddr, HTONS(80));
+ \endcode
+ *
+ * \param addr A pointer to a uip_ipaddr_t variable that will be
+ * filled in with the IP address.
+ *
+ * \param addr0 The first octet of the IP address.
+ * \param addr1 The second octet of the IP address.
+ * \param addr2 The third octet of the IP address.
+ * \param addr3 The forth octet of the IP address.
+ *
+ * \hideinitializer
+ */
+#define uip_ipaddr(addr, addr0,addr1,addr2,addr3) do {  \
+    (addr)->u8[0] = addr0;                              \
+    (addr)->u8[1] = addr1;                              \
+    (addr)->u8[2] = addr2;                              \
+    (addr)->u8[3] = addr3;                              \
+  } while(0)
+
+/**
+ * Construct an IPv6 address from eight 16-bit words.
+ *
+ * This function constructs an IPv6 address.
+ *
+ * \hideinitializer
+ */
+#define uip_ip6addr(addr, addr0,addr1,addr2,addr3,addr4,addr5,addr6,addr7) do { \
+    (addr)->u16[0] = HTONS(addr0);                                      \
+    (addr)->u16[1] = HTONS(addr1);                                      \
+    (addr)->u16[2] = HTONS(addr2);                                      \
+    (addr)->u16[3] = HTONS(addr3);                                      \
+    (addr)->u16[4] = HTONS(addr4);                                      \
+    (addr)->u16[5] = HTONS(addr5);                                      \
+    (addr)->u16[6] = HTONS(addr6);                                      \
+    (addr)->u16[7] = HTONS(addr7);                                      \
+  } while(0)
+
+/**
+ * Construct an IPv6 address from eight 8-bit words.
+ *
+ * This function constructs an IPv6 address.
+ *
+ * \hideinitializer
+ */
+#define uip_ip6addr_u8(addr, addr0,addr1,addr2,addr3,addr4,addr5,addr6,addr7,addr8,addr9,addr10,addr11,addr12,addr13,addr14,addr15) do { \
+    (addr)->u8[0] = addr0;                                       \
+    (addr)->u8[1] = addr1;                                       \
+    (addr)->u8[2] = addr2;                                       \
+    (addr)->u8[3] = addr3;                                       \
+    (addr)->u8[4] = addr4;                                       \
+    (addr)->u8[5] = addr5;                                       \
+    (addr)->u8[6] = addr6;                                       \
+    (addr)->u8[7] = addr7;                                       \
+    (addr)->u8[8] = addr8;                                       \
+    (addr)->u8[9] = addr9;                                       \
+    (addr)->u8[10] = addr10;                                     \
+    (addr)->u8[11] = addr11;                                     \
+    (addr)->u8[12] = addr12;                                     \
+    (addr)->u8[13] = addr13;                                     \
+    (addr)->u8[14] = addr14;                                     \
+    (addr)->u8[15] = addr15;                                     \
+  } while(0)
+
+
+/**
+ * Copy an IP address to another IP address.
+ *
+ * Copies an IP address from one place to another.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr1, ipaddr2;
+
+ uip_ipaddr(&ipaddr1, 192,16,1,2);
+ uip_ipaddr_copy(&ipaddr2, &ipaddr1);
+ \endcode
+ *
+ * \param dest The destination for the copy.
+ * \param src The source from where to copy.
+ *
+ * \hideinitializer
+ */
+#ifndef uip_ipaddr_copy
+#define uip_ipaddr_copy(dest, src) (*(dest) = *(src))
+#endif
+
+/**
+ * Compare two IP addresses
+ *
+ * Compares two IP addresses.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr1, ipaddr2;
+
+ uip_ipaddr(&ipaddr1, 192,16,1,2);
+ if(uip_ipaddr_cmp(&ipaddr2, &ipaddr1)) {
+ printf("They are the same");
+ }
+ \endcode
+ *
+ * \param addr1 The first IP address.
+ * \param addr2 The second IP address.
+ *
+ * \hideinitializer
+ */
+#if !UIP_CONF_IPV6
+#define uip_ipaddr_cmp(addr1, addr2) ((addr1)->u16[0] == (addr2)->u16[0] && \
+				      (addr1)->u16[1] == (addr2)->u16[1])
+#else /* !UIP_CONF_IPV6 */
+#define uip_ipaddr_cmp(addr1, addr2) (memcmp(addr1, addr2, sizeof(uip_ip6addr_t)) == 0)
+#endif /* !UIP_CONF_IPV6 */
+
+/**
+ * Compare two IP addresses with netmasks
+ *
+ * Compares two IP addresses with netmasks. The masks are used to mask
+ * out the bits that are to be compared.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr1, ipaddr2, mask;
+
+ uip_ipaddr(&mask, 255,255,255,0);
+ uip_ipaddr(&ipaddr1, 192,16,1,2);
+ uip_ipaddr(&ipaddr2, 192,16,1,3);
+ if(uip_ipaddr_maskcmp(&ipaddr1, &ipaddr2, &mask)) {
+ printf("They are the same");
+ }
+ \endcode
+ *
+ * \param addr1 The first IP address.
+ * \param addr2 The second IP address.
+ * \param mask The netmask.
+ *
+ * \hideinitializer
+ */
+#if !UIP_CONF_IPV6
+#define uip_ipaddr_maskcmp(addr1, addr2, mask)          \
+  (((((u16_t *)addr1)[0] & ((u16_t *)mask)[0]) ==       \
+    (((u16_t *)addr2)[0] & ((u16_t *)mask)[0])) &&      \
+   ((((u16_t *)addr1)[1] & ((u16_t *)mask)[1]) ==       \
+    (((u16_t *)addr2)[1] & ((u16_t *)mask)[1])))
+#else
+#define uip_ipaddr_prefixcmp(addr1, addr2, length) (memcmp(addr1, addr2, length>>3) == 0)
+#endif
+
+
+/**
+ * Check if an address is a broadcast address for a network.
+ *
+ * Checks if an address is the broadcast address for a network. The
+ * network is defined by an IP address that is on the network and the
+ * network's netmask.
+ *
+ * \param addr The IP address.
+ * \param netaddr The network's IP address.
+ * \param netmask The network's netmask.
+ *
+ * \hideinitializer
+ */
+/*#define uip_ipaddr_isbroadcast(addr, netaddr, netmask)
+  ((uip_ipaddr_t *)(addr)).u16 & ((uip_ipaddr_t *)(addr)).u16*/
+
+
+
+/**
+ * Mask out the network part of an IP address.
+ *
+ * Masks out the network part of an IP address, given the address and
+ * the netmask.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr1, ipaddr2, netmask;
+
+ uip_ipaddr(&ipaddr1, 192,16,1,2);
+ uip_ipaddr(&netmask, 255,255,255,0);
+ uip_ipaddr_mask(&ipaddr2, &ipaddr1, &netmask);
+ \endcode
+ *
+ * In the example above, the variable "ipaddr2" will contain the IP
+ * address 192.168.1.0.
+ *
+ * \param dest Where the result is to be placed.
+ * \param src The IP address.
+ * \param mask The netmask.
+ *
+ * \hideinitializer
+ */
+#define uip_ipaddr_mask(dest, src, mask) do {                           \
+    ((u16_t *)dest)[0] = ((u16_t *)src)[0] & ((u16_t *)mask)[0];        \
+    ((u16_t *)dest)[1] = ((u16_t *)src)[1] & ((u16_t *)mask)[1];        \
+  } while(0)
+
+/**
+ * Pick the first octet of an IP address.
+ *
+ * Picks out the first octet of an IP address.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ u8_t octet;
+
+ uip_ipaddr(&ipaddr, 1,2,3,4);
+ octet = uip_ipaddr1(&ipaddr);
+ \endcode
+ *
+ * In the example above, the variable "octet" will contain the value 1.
+ *
+ * \hideinitializer
+ */
+#define uip_ipaddr1(addr) ((addr)->u8[0])
+
+/**
+ * Pick the second octet of an IP address.
+ *
+ * Picks out the second octet of an IP address.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ u8_t octet;
+
+ uip_ipaddr(&ipaddr, 1,2,3,4);
+ octet = uip_ipaddr2(&ipaddr);
+ \endcode
+ *
+ * In the example above, the variable "octet" will contain the value 2.
+ *
+ * \hideinitializer
+ */
+#define uip_ipaddr2(addr) ((addr)->u8[1])
+
+/**
+ * Pick the third octet of an IP address.
+ *
+ * Picks out the third octet of an IP address.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ u8_t octet;
+
+ uip_ipaddr(&ipaddr, 1,2,3,4);
+ octet = uip_ipaddr3(&ipaddr);
+ \endcode
+ *
+ * In the example above, the variable "octet" will contain the value 3.
+ *
+ * \hideinitializer
+ */
+#define uip_ipaddr3(addr) ((addr)->u8[2])
+
+/**
+ * Pick the fourth octet of an IP address.
+ *
+ * Picks out the fourth octet of an IP address.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ u8_t octet;
+
+ uip_ipaddr(&ipaddr, 1,2,3,4);
+ octet = uip_ipaddr4(&ipaddr);
+ \endcode
+ *
+ * In the example above, the variable "octet" will contain the value 4.
+ *
+ * \hideinitializer
+ */
+#define uip_ipaddr4(addr) ((addr)->u8[3])
+
+/**
+ * Convert 16-bit quantity from host byte order to network byte order.
+ *
+ * This macro is primarily used for converting constants from host
+ * byte order to network byte order. For converting variables to
+ * network byte order, use the htons() function instead.
+ *
+ * \hideinitializer
+ */
+#ifndef HTONS
+#   if UIP_BYTE_ORDER == UIP_BIG_ENDIAN
+#      define HTONS(n) (n)
+#      define HTONL(n) (n)
+#   else /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
+#      define HTONS(n) (u16_t)((((u16_t) (n)) << 8) | (((u16_t) (n)) >> 8))
+#      define HTONL(n) (((u32_t)HTONS(n) << 16) | HTONS((u32_t)(n) >> 16))
+#   endif /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
+#else
+#error "HTONS already defined!"
+#endif /* HTONS */
+
+/**
+ * Convert 16-bit quantity from host byte order to network byte order.
+ *
+ * This function is primarily used for converting variables from host
+ * byte order to network byte order. For converting constants to
+ * network byte order, use the HTONS() macro instead.
+ */
+#ifndef htons
+u16_t htons(u16_t val);
+#endif /* htons */
+#ifndef ntohs
+#define ntohs htons
+#endif
+
+#ifndef htonl
+u32_t htonl(u32_t val);
+#endif /* htonl */
+#ifndef ntohl
+#define ntohl htonl
+#endif
+
+/** @} */
+
+/**
+ * Pointer to the application data in the packet buffer.
+ *
+ * This pointer points to the application data when the application is
+ * called. If the application wishes to send data, the application may
+ * use this space to write the data into before calling uip_send().
+ */
+extern void *uip_appdata;
+
+#if UIP_URGDATA > 0
+/* u8_t *uip_urgdata:
+ *
+ * This pointer points to any urgent data that has been received. Only
+ * present if compiled with support for urgent data (UIP_URGDATA).
+ */
+extern void *uip_urgdata;
+#endif /* UIP_URGDATA > 0 */
+
+
+/**
+ * \defgroup uipdrivervars Variables used in uIP device drivers
+ * @{
+ *
+ * uIP has a few global variables that are used in device drivers for
+ * uIP.
+ */
+
+/**
+ * The length of the packet in the uip_buf buffer.
+ *
+ * The global variable uip_len holds the length of the packet in the
+ * uip_buf buffer.
+ *
+ * When the network device driver calls the uIP input function,
+ * uip_len should be set to the length of the packet in the uip_buf
+ * buffer.
+ *
+ * When sending packets, the device driver should use the contents of
+ * the uip_len variable to determine the length of the outgoing
+ * packet.
+ *
+ */
+extern u16_t uip_len;
+
+/**
+ * The length of the extension headers
+ */
+extern u8_t uip_ext_len;
+/** @} */
+
+#if UIP_URGDATA > 0
+extern u16_t uip_urglen, uip_surglen;
+#endif /* UIP_URGDATA > 0 */
+
+
+/**
+ * Representation of a uIP TCP connection.
+ *
+ * The uip_conn structure is used for identifying a connection. All
+ * but one field in the structure are to be considered read-only by an
+ * application. The only exception is the appstate field whose purpose
+ * is to let the application store application-specific state (e.g.,
+ * file pointers) for the connection. The type of this field is
+ * configured in the "uipopt.h" header file.
+ */
+struct uip_conn {
+  uip_ipaddr_t ripaddr;   /**< The IP address of the remote host. */
+  
+  u16_t lport;        /**< The local TCP port, in network byte order. */
+  u16_t rport;        /**< The local remote TCP port, in network byte
+			 order. */
+  
+  u8_t rcv_nxt[4];    /**< The sequence number that we expect to
+			 receive next. */
+  u8_t snd_nxt[4];    /**< The sequence number that was last sent by
+                         us. */
+  u16_t len;          /**< Length of the data that was previously sent. */
+  u16_t mss;          /**< Current maximum segment size for the
+			 connection. */
+  u16_t initialmss;   /**< Initial maximum segment size for the
+			 connection. */
+  u8_t sa;            /**< Retransmission time-out calculation state
+			 variable. */
+  u8_t sv;            /**< Retransmission time-out calculation state
+			 variable. */
+  u8_t rto;           /**< Retransmission time-out. */
+  u8_t tcpstateflags; /**< TCP state and flags. */
+  u8_t timer;         /**< The retransmission timer. */
+  u8_t nrtx;          /**< The number of retransmissions for the last
+			 segment sent. */
+
+  /** The application state. */
+  uip_tcp_appstate_t appstate;
+};
+
+
+/**
+ * Pointer to the current TCP connection.
+ *
+ * The uip_conn pointer can be used to access the current TCP
+ * connection.
+ */
+
+extern struct uip_conn *uip_conn;
+#if UIP_TCP
+/* The array containing all uIP connections. */
+extern struct uip_conn uip_conns[UIP_CONNS];
+#endif
+
+/**
+ * \addtogroup uiparch
+ * @{
+ */
+
+/**
+ * 4-byte array used for the 32-bit sequence number calculations.
+ */
+extern u8_t uip_acc32[4];
+/** @} */
+
+/**
+ * Representation of a uIP UDP connection.
+ */
+struct uip_udp_conn {
+  uip_ipaddr_t ripaddr;   /**< The IP address of the remote peer. */
+  u16_t lport;        /**< The local port number in network byte order. */
+  u16_t rport;        /**< The remote port number in network byte order. */
+  u8_t  ttl;          /**< Default time-to-live. */
+
+  /** The application state. */
+  uip_udp_appstate_t appstate;
+};
+
+/**
+ * The current UDP connection.
+ */
+extern struct uip_udp_conn *uip_udp_conn;
+extern struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
+
+struct uip_router {
+  int (*activate)(void);
+  int (*deactivate)(void);
+  uip_ipaddr_t *(*lookup)(uip_ipaddr_t *destipaddr, uip_ipaddr_t *nexthop);
+};
+
+#if UIP_CONF_ROUTER
+extern const struct uip_router *uip_router;
+
+/**
+ * uIP routing driver registration function.
+ */
+void uip_router_register(const struct uip_router *router);
+#endif /*UIP_CONF_ROUTER*/
+
+#if UIP_CONF_ICMP6
+struct uip_icmp6_conn {
+  uip_icmp6_appstate_t appstate;
+};
+extern struct uip_icmp6_conn uip_icmp6_conns;
+#endif /*UIP_CONF_ICMP6*/
+
+/**
+ * The uIP TCP/IP statistics.
+ *
+ * This is the variable in which the uIP TCP/IP statistics are gathered.
+ */
+#if UIP_STATISTICS == 1
+extern struct uip_stats uip_stat;
+#define UIP_STAT(s) s
+#else
+#define UIP_STAT(s)
+#endif /* UIP_STATISTICS == 1 */
+
+/**
+ * The structure holding the TCP/IP statistics that are gathered if
+ * UIP_STATISTICS is set to 1.
+ *
+ */
+struct uip_stats {
+  struct {
+    uip_stats_t recv;     /**< Number of received packets at the IP
+			     layer. */
+    uip_stats_t sent;     /**< Number of sent packets at the IP
+			     layer. */
+    uip_stats_t forwarded;/**< Number of forwarded packets at the IP 
+			     layer. */
+    uip_stats_t drop;     /**< Number of dropped packets at the IP
+			     layer. */
+    uip_stats_t vhlerr;   /**< Number of packets dropped due to wrong
+			     IP version or header length. */
+    uip_stats_t hblenerr; /**< Number of packets dropped due to wrong
+			     IP length, high byte. */
+    uip_stats_t lblenerr; /**< Number of packets dropped due to wrong
+			     IP length, low byte. */
+    uip_stats_t fragerr;  /**< Number of packets dropped since they
+			     were IP fragments. */
+    uip_stats_t chkerr;   /**< Number of packets dropped due to IP
+			     checksum errors. */
+    uip_stats_t protoerr; /**< Number of packets dropped since they
+			     were neither ICMP, UDP nor TCP. */
+  } ip;                   /**< IP statistics. */
+  struct {
+    uip_stats_t recv;     /**< Number of received ICMP packets. */
+    uip_stats_t sent;     /**< Number of sent ICMP packets. */
+    uip_stats_t drop;     /**< Number of dropped ICMP packets. */
+    uip_stats_t typeerr;  /**< Number of ICMP packets with a wrong
+			     type. */
+    uip_stats_t chkerr;   /**< Number of ICMP packets with a bad
+			     checksum. */
+  } icmp;                 /**< ICMP statistics. */
+#if UIP_TCP
+  struct {
+    uip_stats_t recv;     /**< Number of recived TCP segments. */
+    uip_stats_t sent;     /**< Number of sent TCP segments. */
+    uip_stats_t drop;     /**< Number of dropped TCP segments. */
+    uip_stats_t chkerr;   /**< Number of TCP segments with a bad
+			     checksum. */
+    uip_stats_t ackerr;   /**< Number of TCP segments with a bad ACK
+			     number. */
+    uip_stats_t rst;      /**< Number of recevied TCP RST (reset) segments. */
+    uip_stats_t rexmit;   /**< Number of retransmitted TCP segments. */
+    uip_stats_t syndrop;  /**< Number of dropped SYNs due to too few
+			     connections was avaliable. */
+    uip_stats_t synrst;   /**< Number of SYNs for closed ports,
+			     triggering a RST. */
+  } tcp;                  /**< TCP statistics. */
+#endif
+#if UIP_UDP
+  struct {
+    uip_stats_t drop;     /**< Number of dropped UDP segments. */
+    uip_stats_t recv;     /**< Number of recived UDP segments. */
+    uip_stats_t sent;     /**< Number of sent UDP segments. */
+    uip_stats_t chkerr;   /**< Number of UDP segments with a bad
+			     checksum. */
+  } udp;                  /**< UDP statistics. */
+#endif /* UIP_UDP */
+#if UIP_CONF_IPV6
+  struct {
+    uip_stats_t drop;     /**< Number of dropped ND6 packets. */
+    uip_stats_t recv;     /**< Number of recived ND6 packets */
+    uip_stats_t sent;     /**< Number of sent ND6 packets */
+  } nd6;
+#endif /*UIP_CONF_IPV6*/
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* All the stuff below this point is internal to uIP and should not be
+ * used directly by an application or by a device driver.
+ */
+/*---------------------------------------------------------------------------*/
+
+
+
+/* u8_t uip_flags:
+ *
+ * When the application is called, uip_flags will contain the flags
+ * that are defined in this file. Please read below for more
+ * information.
+ */
+extern u8_t uip_flags;
+
+/* The following flags may be set in the global variable uip_flags
+   before calling the application callback. The UIP_ACKDATA,
+   UIP_NEWDATA, and UIP_CLOSE flags may both be set at the same time,
+   whereas the others are mutually exclusive. Note that these flags
+   should *NOT* be accessed directly, but only through the uIP
+   functions/macros. */
+
+#define UIP_ACKDATA   1     /* Signifies that the outstanding data was
+			       acked and the application should send
+			       out new data instead of retransmitting
+			       the last data. */
+#define UIP_NEWDATA   2     /* Flags the fact that the peer has sent
+			       us new data. */
+#define UIP_REXMIT    4     /* Tells the application to retransmit the
+			       data that was last sent. */
+#define UIP_POLL      8     /* Used for polling the application, to
+			       check if the application has data that
+			       it wants to send. */
+#define UIP_CLOSE     16    /* The remote host has closed the
+			       connection, thus the connection has
+			       gone away. Or the application signals
+			       that it wants to close the
+			       connection. */
+#define UIP_ABORT     32    /* The remote host has aborted the
+			       connection, thus the connection has
+			       gone away. Or the application signals
+			       that it wants to abort the
+			       connection. */
+#define UIP_CONNECTED 64    /* We have got a connection from a remote
+                               host and have set up a new connection
+                               for it, or an active connection has
+                               been successfully established. */
+
+#define UIP_TIMEDOUT  128   /* The connection has been aborted due to
+			       too many retransmissions. */
+
+
+/**
+ * \brief process the options within a hop by hop or destination option header
+ * \retval 0: nothing to send,
+ * \retval 1: drop pkt
+ * \retval 2: ICMP error message to send
+*/
+/*static u8_t
+uip_ext_hdr_options_process(); */
+
+/* uip_process(flag):
+ *
+ * The actual uIP function which does all the work.
+ */
+void uip_process(u8_t flag);
+  
+  /* The following flags are passed as an argument to the uip_process()
+   function. They are used to distinguish between the two cases where
+   uip_process() is called. It can be called either because we have
+   incoming data that should be processed, or because the periodic
+   timer has fired. These values are never used directly, but only in
+   the macros defined in this file. */
+ 
+#define UIP_DATA          1     /* Tells uIP that there is incoming
+				   data in the uip_buf buffer. The
+				   length of the data is stored in the
+				   global variable uip_len. */
+#define UIP_TIMER         2     /* Tells uIP that the periodic timer
+				   has fired. */
+#define UIP_POLL_REQUEST  3     /* Tells uIP that a connection should
+				   be polled. */
+#define UIP_UDP_SEND_CONN 4     /* Tells uIP that a UDP datagram
+				   should be constructed in the
+				   uip_buf buffer. */
+#if UIP_UDP
+#define UIP_UDP_TIMER     5
+#endif /* UIP_UDP */
+
+/* The TCP states used in the uip_conn->tcpstateflags. */
+#define UIP_CLOSED      0
+#define UIP_SYN_RCVD    1
+#define UIP_SYN_SENT    2
+#define UIP_ESTABLISHED 3
+#define UIP_FIN_WAIT_1  4
+#define UIP_FIN_WAIT_2  5
+#define UIP_CLOSING     6
+#define UIP_TIME_WAIT   7
+#define UIP_LAST_ACK    8
+#define UIP_TS_MASK     15
+  
+#define UIP_STOPPED      16
+
+/* The TCP and IP headers. */
+struct uip_tcpip_hdr {
+#if UIP_CONF_IPV6
+  /* IPv6 header. */
+  u8_t vtc,
+    tcflow;
+  u16_t flow;
+  u8_t len[2];
+  u8_t proto, ttl;
+  uip_ip6addr_t srcipaddr, destipaddr;
+#else /* UIP_CONF_IPV6 */
+  /* IPv4 header. */
+  u8_t vhl,
+    tos,
+    len[2],
+    ipid[2],
+    ipoffset[2],
+    ttl,
+    proto;
+  u16_t ipchksum;
+  uip_ipaddr_t srcipaddr, destipaddr;
+#endif /* UIP_CONF_IPV6 */
+  
+  /* TCP header. */
+  u16_t srcport,
+    destport;
+  u8_t seqno[4],
+    ackno[4],
+    tcpoffset,
+    flags,
+    wnd[2];
+  u16_t tcpchksum;
+  u8_t urgp[2];
+  u8_t optdata[4];
+};
+
+/* The ICMP and IP headers. */
+struct uip_icmpip_hdr {
+#if UIP_CONF_IPV6
+  /* IPv6 header. */
+  u8_t vtc,
+    tcf;
+  u16_t flow;
+  u8_t len[2];
+  u8_t proto, ttl;
+  uip_ip6addr_t srcipaddr, destipaddr;
+#else /* UIP_CONF_IPV6 */
+  /* IPv4 header. */
+  u8_t vhl,
+    tos,
+    len[2],
+    ipid[2],
+    ipoffset[2],
+    ttl,
+    proto;
+  u16_t ipchksum;
+  uip_ipaddr_t srcipaddr, destipaddr;
+#endif /* UIP_CONF_IPV6 */
+  
+  /* ICMP header. */
+  u8_t type, icode;
+  u16_t icmpchksum;
+#if !UIP_CONF_IPV6
+  u16_t id, seqno;
+  u8_t payload[1];
+#endif /* !UIP_CONF_IPV6 */
+};
+
+
+/* The UDP and IP headers. */
+struct uip_udpip_hdr {
+#if UIP_CONF_IPV6
+  /* IPv6 header. */
+  u8_t vtc,
+    tcf;
+  u16_t flow;
+  u8_t len[2];
+  u8_t proto, ttl;
+  uip_ip6addr_t srcipaddr, destipaddr;
+#else /* UIP_CONF_IPV6 */
+  /* IP header. */
+  u8_t vhl,
+    tos,
+    len[2],
+    ipid[2],
+    ipoffset[2],
+    ttl,
+    proto;
+  u16_t ipchksum;
+  uip_ipaddr_t srcipaddr, destipaddr;
+#endif /* UIP_CONF_IPV6 */
+  
+  /* UDP header. */
+  u16_t srcport,
+    destport;
+  u16_t udplen;
+  u16_t udpchksum;
+};
+
+/*
+ * In IPv6 the length of the L3 headers before the transport header is
+ * not fixed, due to the possibility to include extension option headers
+ * after the IP header. hence we split here L3 and L4 headers
+ */
+/* The IP header */
+struct uip_ip_hdr {
+#if UIP_CONF_IPV6
+  /* IPV6 header */
+  u8_t vtc;
+  u8_t tcflow;
+  u16_t flow;
+  u8_t len[2];
+  u8_t proto, ttl;
+  uip_ip6addr_t srcipaddr, destipaddr;
+#else /* UIP_CONF_IPV6 */
+  /* IPV4 header */
+  u8_t vhl,
+    tos,
+    len[2],
+    ipid[2],
+    ipoffset[2],
+    ttl,
+    proto;
+  u16_t ipchksum;
+  uip_ipaddr_t srcipaddr, destipaddr;
+#endif /* UIP_CONF_IPV6 */
+};
+
+
+/*
+ * IPv6 extension option headers: we are able to process
+ * the 4 extension headers defined in RFC2460 (IPv6):
+ * - Hop by hop option header, destination option header:
+ *   These two are not used by any core IPv6 protocol, hence
+ *   we just read them and go to the next. They convey options,
+ *   the options defined in RFC2460 are Pad1 and PadN, which do
+ *   some padding, and that we do not need to read (the length
+ *   field in the header is enough)
+ * - Routing header: this one is most notably used by MIPv6,
+ *   which we do not implement, hence we just read it and go
+ *   to the next
+ * - Fragmentation header: we read this header and are able to
+ *   reassemble packets
+ *
+ * We do not offer any means to send packets with extension headers
+ *
+ * We do not implement Authentication and ESP headers, which are
+ * used in IPSec and defined in RFC4302,4303,4305,4385
+ */
+/* common header part */
+struct uip_ext_hdr {
+  u8_t next;
+  u8_t len;
+};
+
+/* Hop by Hop option header */
+struct uip_hbho_hdr {
+  u8_t next;
+  u8_t len;
+};
+
+/* destination option header */
+struct uip_desto_hdr {
+  u8_t next;
+  u8_t len;
+};
+
+/* We do not define structures for PAD1 and PADN options */
+
+/*
+ * routing header
+ * the routing header as 4 common bytes, then routing header type
+ * specific data there are several types of routing header. Type 0 was
+ * deprecated as per RFC5095 most notable other type is 2, used in
+ * RFC3775 (MIPv6) here we do not implement MIPv6, so we just need to
+ * parse the 4 first bytes
+ */
+struct uip_routing_hdr {
+  u8_t next;
+  u8_t len;
+  u8_t routing_type;
+  u8_t seg_left;
+};
+
+/* fragmentation header */
+struct uip_frag_hdr {
+  u8_t next;
+  u8_t res;
+  u16_t offsetresmore;
+  u32_t id;
+};
+
+/*
+ * an option within the destination or hop by hop option headers
+ * it contains type an length, which is true for all options but PAD1
+ */
+struct uip_ext_hdr_opt {
+  u8_t type;
+  u8_t len;
+};
+
+/* PADN option */
+struct uip_ext_hdr_opt_padn {
+  u8_t opt_type;
+  u8_t opt_len;
+};
+
+/* TCP header */
+struct uip_tcp_hdr {
+  u16_t srcport;
+  u16_t destport;
+  u8_t seqno[4];
+  u8_t ackno[4];
+  u8_t tcpoffset;
+  u8_t flags;
+  u8_t  wnd[2];
+  u16_t tcpchksum;
+  u8_t urgp[2];
+  u8_t optdata[4];
+};
+
+/* The ICMP headers. */
+struct uip_icmp_hdr {
+  u8_t type, icode;
+  u16_t icmpchksum;
+#if !UIP_CONF_IPV6
+  u16_t id, seqno;
+#endif /* !UIP_CONF_IPV6 */
+};
+
+
+/* The UDP headers. */
+struct uip_udp_hdr {
+  u16_t srcport;
+  u16_t destport;
+  u16_t udplen;
+  u16_t udpchksum;
+};
+
+
+/**
+ * The buffer size available for user data in the \ref uip_buf buffer.
+ *
+ * This macro holds the available size for user data in the \ref
+ * uip_buf buffer. The macro is intended to be used for checking
+ * bounds of available user data.
+ *
+ * Example:
+ \code
+ snprintf(uip_appdata, UIP_APPDATA_SIZE, "%u\n", i);
+ \endcode
+ *
+ * \hideinitializer
+ */
+#define UIP_APPDATA_SIZE (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)
+#define UIP_APPDATA_PTR (void *)&uip_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN]
+
+#define UIP_PROTO_ICMP  1
+#define UIP_PROTO_TCP   6
+#define UIP_PROTO_UDP   17
+#define UIP_PROTO_ICMP6 58
+
+
+#if UIP_CONF_IPV6
+/** @{ */
+/** \brief  extension headers types */
+#define UIP_PROTO_HBHO        0
+#define UIP_PROTO_DESTO       60
+#define UIP_PROTO_ROUTING     43
+#define UIP_PROTO_FRAG        44
+#define UIP_PROTO_NONE        59
+/** @} */
+
+/** @{ */
+/** \brief  Destination and Hop By Hop extension headers option types */
+#define UIP_EXT_HDR_OPT_PAD1  0
+#define UIP_EXT_HDR_OPT_PADN  1
+/** @} */
+
+/** @{ */
+/**
+ * \brief Bitmaps for extension header processing
+ *
+ * When processing extension headers, we should record somehow which one we
+ * see, because you cannot have twice the same header, except for destination
+ * We store all this in one u8_t bitmap one bit for each header expected. The
+ * order in the bitmap is the order recommended in RFC2460
+ */
+#define UIP_EXT_HDR_BITMAP_HBHO 0x01
+#define UIP_EXT_HDR_BITMAP_DESTO1 0x02
+#define UIP_EXT_HDR_BITMAP_ROUTING 0x04
+#define UIP_EXT_HDR_BITMAP_FRAG 0x08
+#define UIP_EXT_HDR_BITMAP_AH 0x10
+#define UIP_EXT_HDR_BITMAP_ESP 0x20
+#define UIP_EXT_HDR_BITMAP_DESTO2 0x40
+/** @} */
+
+
+#endif /* UIP_CONF_IPV6 */
+
+
+/* Header sizes. */
+#if UIP_CONF_IPV6
+#define UIP_IPH_LEN    40
+#define UIP_FRAGH_LEN  8
+#else /* UIP_CONF_IPV6 */
+#define UIP_IPH_LEN    20    /* Size of IP header */
+#endif /* UIP_CONF_IPV6 */
+
+#define UIP_UDPH_LEN    8    /* Size of UDP header */
+#define UIP_TCPH_LEN   20    /* Size of TCP header */
+#ifdef UIP_IPH_LEN
+#define UIP_ICMPH_LEN   4    /* Size of ICMP header */
+#endif
+#define UIP_IPUDPH_LEN (UIP_UDPH_LEN + UIP_IPH_LEN)    /* Size of IP +
+                        * UDP
+							   * header */
+#define UIP_IPTCPH_LEN (UIP_TCPH_LEN + UIP_IPH_LEN)    /* Size of IP +
+							   * TCP
+							   * header */
+#define UIP_TCPIP_HLEN UIP_IPTCPH_LEN
+#define UIP_IPICMPH_LEN (UIP_IPH_LEN + UIP_ICMPH_LEN) /* size of ICMP
+                                                         + IP header */
+#define UIP_LLIPH_LEN (UIP_LLH_LEN + UIP_IPH_LEN)    /* size of L2
+                                                        + IP header */
+#if UIP_CONF_IPV6
+/**
+ * The sums below are quite used in ND. When used for uip_buf, we
+ * include link layer length when used for uip_len, we do not, hence
+ * we need values with and without LLH_LEN we do not use capital
+ * letters as these values are variable
+ */
+#define uip_l2_l3_hdr_len (UIP_LLH_LEN + UIP_IPH_LEN + uip_ext_len)
+#define uip_l2_l3_icmp_hdr_len (UIP_LLH_LEN + UIP_IPH_LEN + uip_ext_len + UIP_ICMPH_LEN)
+#define uip_l3_hdr_len (UIP_IPH_LEN + uip_ext_len)
+#define uip_l3_icmp_hdr_len (UIP_IPH_LEN + uip_ext_len + UIP_ICMPH_LEN)
+#endif /*UIP_CONF_IPV6*/
+
+
+#if UIP_FIXEDADDR
+extern const uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
+#else /* UIP_FIXEDADDR */
+extern uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
+#endif /* UIP_FIXEDADDR */
+extern const uip_ipaddr_t uip_broadcast_addr;
+extern const uip_ipaddr_t uip_all_zeroes_addr;
+
+#if UIP_FIXEDETHADDR
+extern const uip_lladdr_t uip_lladdr;
+#else
+extern uip_lladdr_t uip_lladdr;
+#endif
+
+
+
+
+#ifdef UIP_CONF_IPV6
+/**
+ * \brief Is IPv6 address a the unspecified address
+ * a is of type uip_ipaddr_t
+ */
+#define uip_is_addr_unspecified(a)               \
+  ((((a)->u16[0]) == 0) &&                       \
+   (((a)->u16[1]) == 0) &&                       \
+   (((a)->u16[2]) == 0) &&                       \
+   (((a)->u16[3]) == 0) &&                       \
+   (((a)->u16[4]) == 0) &&                       \
+   (((a)->u16[5]) == 0) &&                       \
+   (((a)->u16[6]) == 0) &&                       \
+   (((a)->u16[7]) == 0))
+
+/** \brief Is IPv6 address a the link local all-nodes multicast address */
+#define uip_is_addr_linklocal_allnodes_mcast(a)     \
+  ((((a)->u8[0]) == 0xff) &&                        \
+   (((a)->u8[1]) == 0x02) &&                        \
+   (((a)->u16[1]) == 0) &&                          \
+   (((a)->u16[2]) == 0) &&                          \
+   (((a)->u16[3]) == 0) &&                          \
+   (((a)->u16[4]) == 0) &&                          \
+   (((a)->u16[5]) == 0) &&                          \
+   (((a)->u16[6]) == 0) &&                          \
+   (((a)->u8[14]) == 0) &&                          \
+   (((a)->u8[15]) == 0x01))
+
+/** \brief set IP address a to unspecified */
+#define uip_create_unspecified(a) uip_ip6addr(a, 0, 0, 0, 0, 0, 0, 0, 0)
+
+/** \brief set IP address a to the link local all-nodes multicast address */
+#define uip_create_linklocal_allnodes_mcast(a) uip_ip6addr(a, 0xff02, 0, 0, 0, 0, 0, 0, 0x0001)
+
+/** \brief set IP address a to the link local all-routers multicast address */
+#define uip_create_linklocal_allrouters_mcast(a) uip_ip6addr(a, 0xff02, 0, 0, 0, 0, 0, 0, 0x0002)
+
+/**
+ * \brief  is addr (a) a solicited node multicast address, see RFC3513
+ *  a is of type uip_ipaddr_t*
+ */
+#define uip_is_addr_solicited_node(a)           \
+  ((((a)->u8[0]) == 0xFF) &&                     \
+  (((a)->u8[1]) == 0x02) &&                     \
+  (((a)->u16[1]) == 0) &&                       \
+  (((a)->u16[2]) == 0) &&                       \
+  (((a)->u16[3]) == 0) &&                       \
+  (((a)->u16[4]) == 0) &&                       \
+  (((a)->u16[5]) == 1) &&                       \
+  (((a)->u8[12]) == 0xFF))
+
+/**
+ * \briefput in b the solicited node address corresponding to address a
+ * both a and b are of type uip_ipaddr_t*
+ * */
+#define uip_create_solicited_node(a, b)    \
+  (((b)->u8[0]) = 0xFF);                        \
+  (((b)->u8[1]) = 0x02);                        \
+  (((b)->u16[1]) = 0);                          \
+  (((b)->u16[2]) = 0);                          \
+  (((b)->u16[3]) = 0);                          \
+  (((b)->u16[4]) = 0);                          \
+  (((b)->u8[10]) = 0);                          \
+  (((b)->u8[11]) = 0x01);                       \
+  (((b)->u8[12]) = 0xFF);                       \
+  (((b)->u8[13]) = ((a)->u8[13]));              \
+  (((b)->u16[7]) = ((a)->u16[7]))
+
+/**
+ * \brief is addr (a) a link local unicast address, see RFC3513
+ *  i.e. is (a) on prefix FE80::/10
+ *  a is of type uip_ipaddr_t*
+ */
+#define uip_is_addr_link_local(a) \
+  ((((a)->u8[0]) == 0xFE) && \
+  (((a)->u8[1]) == 0x80))
+
+/**
+ * \brief was addr (a) forged based on the mac address m
+ * a type is uip_ipaddr_t
+ * m type is uiplladdr_t
+ */
+#if UIP_CONF_LL_802154
+#define uip_is_addr_mac_addr_based(a, m) \
+  ((((a)->u8[8])  == (((m)->addr[0]) ^ 0x02)) &&   \
+   (((a)->u8[9])  == (m)->addr[1]) &&            \
+   (((a)->u8[10]) == (m)->addr[2]) &&            \
+   (((a)->u8[11]) == (m)->addr[3]) &&            \
+   (((a)->u8[12]) == (m)->addr[4]) &&            \
+   (((a)->u8[13]) == (m)->addr[5]) &&            \
+   (((a)->u8[14]) == (m)->addr[6]) &&            \
+   (((a)->u8[15]) == (m)->addr[7]))
+#else
+
+#define uip_is_addr_mac_addr_based(a, m) \
+  ((((a)->u8[8])  == (((m)->addr[0]) | 0x02)) &&   \
+   (((a)->u8[9])  == (m)->addr[1]) &&            \
+   (((a)->u8[10]) == (m)->addr[2]) &&            \
+   (((a)->u8[11]) == 0xff) &&            \
+   (((a)->u8[12]) == 0xfe) &&            \
+   (((a)->u8[13]) == (m)->addr[3]) &&            \
+   (((a)->u8[14]) == (m)->addr[4]) &&            \
+   (((a)->u8[15]) == (m)->addr[5]))
+   
+#endif /*UIP_CONF_LL_802154*/
+
+/**
+ * \brief is address a multicast address, see RFC 3513
+ * a is of type uip_ipaddr_t*
+ * */
+#define uip_is_addr_mcast(a)                    \
+  (((a)->u8[0]) == 0xFF)
+
+/**
+ * \brief is group-id of multicast address a
+ * the all nodes group-id
+ */
+#define uip_is_mcast_group_id_all_nodes(a) \
+  ((((a)->u16[1])  == 0) &&                 \
+   (((a)->u16[2])  == 0) &&                 \
+   (((a)->u16[3])  == 0) &&                 \
+   (((a)->u16[4])  == 0) &&                 \
+   (((a)->u16[5])  == 0) &&                 \
+   (((a)->u16[6])  == 0) &&                 \
+   (((a)->u8[14])  == 0) &&                 \
+   (((a)->u8[15])  == 1))
+
+/**
+ * \brief is group-id of multicast address a
+ * the all routers group-id
+ */
+#define uip_is_mcast_group_id_all_routers(a) \
+  ((((a)->u16[1])  == 0) &&                 \
+   (((a)->u16[2])  == 0) &&                 \
+   (((a)->u16[3])  == 0) &&                 \
+   (((a)->u16[4])  == 0) &&                 \
+   (((a)->u16[5])  == 0) &&                 \
+   (((a)->u16[6])  == 0) &&                 \
+   (((a)->u8[14])  == 0) &&                 \
+   (((a)->u8[15])  == 2))
+
+
+#endif /*UIP_CONF_IPV6*/
+
+/**
+ * Calculate the Internet checksum over a buffer.
+ *
+ * The Internet checksum is the one's complement of the one's
+ * complement sum of all 16-bit words in the buffer.
+ *
+ * See RFC1071.
+ *
+ * \param buf A pointer to the buffer over which the checksum is to be
+ * computed.
+ *
+ * \param len The length of the buffer over which the checksum is to
+ * be computed.
+ *
+ * \return The Internet checksum of the buffer.
+ */
+u16_t uip_chksum(u16_t *buf, u16_t len);
+
+/**
+ * Calculate the IP header checksum of the packet header in uip_buf.
+ *
+ * The IP header checksum is the Internet checksum of the 20 bytes of
+ * the IP header.
+ *
+ * \return The IP header checksum of the IP header in the uip_buf
+ * buffer.
+ */
+u16_t uip_ipchksum(void);
+
+/**
+ * Calculate the TCP checksum of the packet in uip_buf and uip_appdata.
+ *
+ * The TCP checksum is the Internet checksum of data contents of the
+ * TCP segment, and a pseudo-header as defined in RFC793.
+ *
+ * \return The TCP checksum of the TCP segment in uip_buf and pointed
+ * to by uip_appdata.
+ */
+u16_t uip_tcpchksum(void);
+
+/**
+ * Calculate the UDP checksum of the packet in uip_buf and uip_appdata.
+ *
+ * The UDP checksum is the Internet checksum of data contents of the
+ * UDP segment, and a pseudo-header as defined in RFC768.
+ *
+ * \return The UDP checksum of the UDP segment in uip_buf and pointed
+ * to by uip_appdata.
+ */
+u16_t uip_udpchksum(void);
+
+/**
+ * Calculate the ICMP checksum of the packet in uip_buf.
+ *
+ * \return The ICMP checksum of the ICMP packet in uip_buf
+ */
+u16_t uip_icmp6chksum(void);
+
+
+#endif /* __UIP_H__ */
+
+
+/** @} */
diff --git a/Projects/Webserver/Lib/uip/uip_arp.c b/Projects/Webserver/Lib/uip/uip_arp.c
index 88c14cc01..56dff9c43 100644
--- a/Projects/Webserver/Lib/uip/uip_arp.c
+++ b/Projects/Webserver/Lib/uip/uip_arp.c
@@ -1,431 +1,431 @@
-/**

- * \addtogroup uip

- * @{

- */

-

-/**

- * \defgroup uiparp uIP Address Resolution Protocol

- * @{

- *

- * The Address Resolution Protocol ARP is used for mapping between IP

- * addresses and link level addresses such as the Ethernet MAC

- * addresses. ARP uses broadcast queries to ask for the link level

- * address of a known IP address and the host which is configured with

- * the IP address for which the query was meant, will respond with its

- * link level address.

- *

- * \note This ARP implementation only supports Ethernet.

- */

- 

-/**

- * \file

- * Implementation of the ARP Address Resolution Protocol.

- * \author Adam Dunkels <adam@dunkels.com>

- *

- */

-

-/*

- * Copyright (c) 2001-2003, Adam Dunkels.

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- * 1. Redistributions of source code must retain the above copyright

- *    notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- *    notice, this list of conditions and the following disclaimer in the

- *    documentation and/or other materials provided with the distribution.

- * 3. The name of the author may not be used to endorse or promote

- *    products derived from this software without specific prior

- *    written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS

- * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE

- * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- *

- * This file is part of the uIP TCP/IP stack.

- *

- * $Id: uip_arp.c,v 1.5 2008/02/07 01:35:00 adamdunkels Exp $

- *

- */

-

-

-#include "uip_arp.h"

-

-#include <string.h>

-

-struct arp_hdr {

-  struct uip_eth_hdr ethhdr;

-  u16_t hwtype;

-  u16_t protocol;

-  u8_t hwlen;

-  u8_t protolen;

-  u16_t opcode;

-  struct uip_eth_addr shwaddr;

-  uip_ipaddr_t sipaddr;

-  struct uip_eth_addr dhwaddr;

-  uip_ipaddr_t dipaddr;

-};

-

-struct ethip_hdr {

-  struct uip_eth_hdr ethhdr;

-  /* IP header. */

-  u8_t vhl,

-    tos,

-    len[2],

-    ipid[2],

-    ipoffset[2],

-    ttl,

-    proto;

-  u16_t ipchksum;

-  uip_ipaddr_t srcipaddr, destipaddr;

-};

-

-#define ARP_REQUEST 1

-#define ARP_REPLY   2

-

-#define ARP_HWTYPE_ETH 1

-

-struct arp_entry {

-  uip_ipaddr_t ipaddr;

-  struct uip_eth_addr ethaddr;

-  u8_t time;

-};

-

-static const struct uip_eth_addr broadcast_ethaddr =

-  {{0xff,0xff,0xff,0xff,0xff,0xff}};

-static const u16_t broadcast_ipaddr[2] = {0xffff,0xffff};

-

-static struct arp_entry arp_table[UIP_ARPTAB_SIZE];

-static uip_ipaddr_t ipaddr;

-static u8_t i, c;

-

-static u8_t arptime;

-static u8_t tmpage;

-

-#define BUF   ((struct arp_hdr *)&uip_buf[0])

-#define IPBUF ((struct ethip_hdr *)&uip_buf[0])

-

-#define DEBUG 0

-#if DEBUG

-#include <stdio.h>

-#define PRINTF(...) printf(__VA_ARGS__)

-#else

-#define PRINTF(...)

-#endif

-

-/*-----------------------------------------------------------------------------------*/

-/**

- * Initialize the ARP module.

- *

- */

-/*-----------------------------------------------------------------------------------*/

-void

-uip_arp_init(void)

-{

-  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {

-    memset(&arp_table[i].ipaddr, 0, 4);

-  }

-}

-/*-----------------------------------------------------------------------------------*/

-/**

- * Periodic ARP processing function.

- *

- * This function performs periodic timer processing in the ARP module

- * and should be called at regular intervals. The recommended interval

- * is 10 seconds between the calls.

- *

- */

-/*-----------------------------------------------------------------------------------*/

-void

-uip_arp_timer(void)

-{

-  struct arp_entry *tabptr = NULL;

-  

-  ++arptime;

-  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {

-    tabptr = &arp_table[i];

-    if(uip_ipaddr_cmp(&tabptr->ipaddr, &uip_all_zeroes_addr) &&

-       arptime - tabptr->time >= UIP_ARP_MAXAGE) {

-      memset(&tabptr->ipaddr, 0, 4);

-    }

-  }

-

-}

-/*-----------------------------------------------------------------------------------*/

-static void

-uip_arp_update(uip_ipaddr_t *ipaddr, struct uip_eth_addr *ethaddr)

-{

-  register struct arp_entry *tabptr = NULL;

-  /* Walk through the ARP mapping table and try to find an entry to

-     update. If none is found, the IP -> MAC address mapping is

-     inserted in the ARP table. */

-  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {

-

-    tabptr = &arp_table[i];

-    /* Only check those entries that are actually in use. */

-    if(!uip_ipaddr_cmp(&tabptr->ipaddr, &uip_all_zeroes_addr)) {

-

-      /* Check if the source IP address of the incoming packet matches

-         the IP address in this ARP table entry. */

-      if(uip_ipaddr_cmp(ipaddr, &tabptr->ipaddr)) {

-	 

-	/* An old entry found, update this and return. */

-	memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6);

-	tabptr->time = arptime;

-

-	return;

-      }

-    }

-  }

-

-  /* If we get here, no existing ARP table entry was found, so we

-     create one. */

-

-  /* First, we try to find an unused entry in the ARP table. */

-  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {

-    tabptr = &arp_table[i];

-    if(uip_ipaddr_cmp(&tabptr->ipaddr, &uip_all_zeroes_addr)) {

-      break;

-    }

-  }

-

-  /* If no unused entry is found, we try to find the oldest entry and

-     throw it away. */

-  if(i == UIP_ARPTAB_SIZE) {

-    tmpage = 0;

-    c = 0;

-    for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {

-      tabptr = &arp_table[i];

-      if(arptime - tabptr->time > tmpage) {

-	tmpage = arptime - tabptr->time;

-	c = i;

-      }

-    }

-    i = c;

-    tabptr = &arp_table[i];

-  }

-

-  /* Now, i is the ARP table entry which we will fill with the new

-     information. */

-  uip_ipaddr_copy(&tabptr->ipaddr, ipaddr);

-  memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6);

-  tabptr->time = arptime;

-}

-/*-----------------------------------------------------------------------------------*/

-/**

- * ARP processing for incoming IP packets

- *

- * This function should be called by the device driver when an IP

- * packet has been received. The function will check if the address is

- * in the ARP cache, and if so the ARP cache entry will be

- * refreshed. If no ARP cache entry was found, a new one is created.

- *

- * This function expects an IP packet with a prepended Ethernet header

- * in the uip_buf[] buffer, and the length of the packet in the global

- * variable uip_len.

- */

-/*-----------------------------------------------------------------------------------*/

-#if 0

-void

-uip_arp_ipin(void)

-{

-  uip_len -= sizeof(struct uip_eth_hdr);

-	

-  /* Only insert/update an entry if the source IP address of the

-     incoming IP packet comes from a host on the local network. */

-  if((IPBUF->srcipaddr[0] & uip_netmask[0]) !=

-     (uip_hostaddr[0] & uip_netmask[0])) {

-    return;

-  }

-  if((IPBUF->srcipaddr[1] & uip_netmask[1]) !=

-     (uip_hostaddr[1] & uip_netmask[1])) {

-    return;

-  }

-  uip_arp_update(IPBUF->srcipaddr, &(IPBUF->ethhdr.src));

-  

-  return;

-}

-#endif /* 0 */

-/*-----------------------------------------------------------------------------------*/

-/**

- * ARP processing for incoming ARP packets.

- *

- * This function should be called by the device driver when an ARP

- * packet has been received. The function will act differently

- * depending on the ARP packet type: if it is a reply for a request

- * that we previously sent out, the ARP cache will be filled in with

- * the values from the ARP reply. If the incoming ARP packet is an ARP

- * request for our IP address, an ARP reply packet is created and put

- * into the uip_buf[] buffer.

- *

- * When the function returns, the value of the global variable uip_len

- * indicates whether the device driver should send out a packet or

- * not. If uip_len is zero, no packet should be sent. If uip_len is

- * non-zero, it contains the length of the outbound packet that is

- * present in the uip_buf[] buffer.

- *

- * This function expects an ARP packet with a prepended Ethernet

- * header in the uip_buf[] buffer, and the length of the packet in the

- * global variable uip_len.

- */

-/*-----------------------------------------------------------------------------------*/

-void

-uip_arp_arpin(void)

-{

-  if(uip_len < sizeof(struct arp_hdr)) {

-    uip_len = 0;

-    return;

-  }

-  uip_len = 0;

-  

-  switch(BUF->opcode) {

-  case HTONS(ARP_REQUEST):

-    /* ARP request. If it asked for our address, we send out a

-       reply. */

-    /*    if(BUF->dipaddr[0] == uip_hostaddr[0] &&

-	  BUF->dipaddr[1] == uip_hostaddr[1]) {*/

-    PRINTF("uip_arp_arpin: request for %d.%d.%d.%d (we are %d.%d.%d.%d)\n",

-	   BUF->dipaddr.u8[0], BUF->dipaddr.u8[1],

-	   BUF->dipaddr.u8[2], BUF->dipaddr.u8[3],

-	   uip_hostaddr.u8[0], uip_hostaddr.u8[1],

-	   uip_hostaddr.u8[2], uip_hostaddr.u8[3]);

-    if(uip_ipaddr_cmp(&BUF->dipaddr, &uip_hostaddr)) {

-      /* First, we register the one who made the request in our ARP

-	 table, since it is likely that we will do more communication

-	 with this host in the future. */

-      uip_arp_update(&BUF->sipaddr, &BUF->shwaddr);

-      

-      BUF->opcode = HTONS(ARP_REPLY);

-

-      memcpy(BUF->dhwaddr.addr, BUF->shwaddr.addr, 6);

-      memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);

-      memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);

-      memcpy(BUF->ethhdr.dest.addr, BUF->dhwaddr.addr, 6);

-      

-      uip_ipaddr_copy(&BUF->dipaddr, &BUF->sipaddr);

-      uip_ipaddr_copy(&BUF->sipaddr, &uip_hostaddr);

-

-      BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);

-      uip_len = sizeof(struct arp_hdr);

-    }

-    break;

-  case HTONS(ARP_REPLY):

-    /* ARP reply. We insert or update the ARP table if it was meant

-       for us. */

-    if(uip_ipaddr_cmp(&BUF->dipaddr, &uip_hostaddr)) {

-      uip_arp_update(&BUF->sipaddr, &BUF->shwaddr);

-    }

-    break;

-  }

-

-  return;

-}

-/*-----------------------------------------------------------------------------------*/

-/**

- * Prepend Ethernet header to an outbound IP packet and see if we need

- * to send out an ARP request.

- *

- * This function should be called before sending out an IP packet. The

- * function checks the destination IP address of the IP packet to see

- * what Ethernet MAC address that should be used as a destination MAC

- * address on the Ethernet.

- *

- * If the destination IP address is in the local network (determined

- * by logical ANDing of netmask and our IP address), the function

- * checks the ARP cache to see if an entry for the destination IP

- * address is found. If so, an Ethernet header is prepended and the

- * function returns. If no ARP cache entry is found for the

- * destination IP address, the packet in the uip_buf[] is replaced by

- * an ARP request packet for the IP address. The IP packet is dropped

- * and it is assumed that they higher level protocols (e.g., TCP)

- * eventually will retransmit the dropped packet.

- *

- * If the destination IP address is not on the local network, the IP

- * address of the default router is used instead.

- *

- * When the function returns, a packet is present in the uip_buf[]

- * buffer, and the length of the packet is in the global variable

- * uip_len.

- */

-/*-----------------------------------------------------------------------------------*/

-void

-uip_arp_out(void)

-{

-  struct arp_entry *tabptr = NULL;

-  

-  /* Find the destination IP address in the ARP table and construct

-     the Ethernet header. If the destination IP addres isn't on the

-     local network, we use the default router's IP address instead.

-

-     If not ARP table entry is found, we overwrite the original IP

-     packet with an ARP request for the IP address. */

-

-  /* First check if destination is a local broadcast. */

-  if(uip_ipaddr_cmp(&IPBUF->destipaddr, &uip_broadcast_addr)) {

-    memcpy(IPBUF->ethhdr.dest.addr, broadcast_ethaddr.addr, 6);

-  } else {

-    /* Check if the destination address is on the local network. */

-    if(!uip_ipaddr_maskcmp(&IPBUF->destipaddr, &uip_hostaddr, &uip_netmask)) {

-      /* Destination address was not on the local network, so we need to

-	 use the default router's IP address instead of the destination

-	 address when determining the MAC address. */

-      uip_ipaddr_copy(&ipaddr, &uip_draddr);

-    } else {

-      /* Else, we use the destination IP address. */

-      uip_ipaddr_copy(&ipaddr, &IPBUF->destipaddr);

-    }

-      

-    for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {

-      tabptr = &arp_table[i];

-      if(uip_ipaddr_cmp(&ipaddr, &tabptr->ipaddr)) {

-	break;

-      }

-    }

-

-    if(i == UIP_ARPTAB_SIZE) {

-      /* The destination address was not in our ARP table, so we

-	 overwrite the IP packet with an ARP request. */

-

-      memset(BUF->ethhdr.dest.addr, 0xff, 6);

-      memset(BUF->dhwaddr.addr, 0x00, 6);

-      memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);

-      memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);

-    

-      uip_ipaddr_copy(&BUF->dipaddr, &ipaddr);

-      uip_ipaddr_copy(&BUF->sipaddr, &uip_hostaddr);

-      BUF->opcode = HTONS(ARP_REQUEST); /* ARP request. */

-      BUF->hwtype = HTONS(ARP_HWTYPE_ETH);

-      BUF->protocol = HTONS(UIP_ETHTYPE_IP);

-      BUF->hwlen = 6;

-      BUF->protolen = 4;

-      BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);

-

-      uip_appdata = &uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN];

-    

-      uip_len = sizeof(struct arp_hdr);

-      return;

-    }

-

-    /* Build an ethernet header. */

-    memcpy(IPBUF->ethhdr.dest.addr, tabptr->ethaddr.addr, 6);

-  }

-  memcpy(IPBUF->ethhdr.src.addr, uip_ethaddr.addr, 6);

-  

-  IPBUF->ethhdr.type = HTONS(UIP_ETHTYPE_IP);

-

-  uip_len += sizeof(struct uip_eth_hdr);

-}

-/*-----------------------------------------------------------------------------------*/

-

-/** @} */

-/** @} */

+/**
+ * \addtogroup uip
+ * @{
+ */
+
+/**
+ * \defgroup uiparp uIP Address Resolution Protocol
+ * @{
+ *
+ * The Address Resolution Protocol ARP is used for mapping between IP
+ * addresses and link level addresses such as the Ethernet MAC
+ * addresses. ARP uses broadcast queries to ask for the link level
+ * address of a known IP address and the host which is configured with
+ * the IP address for which the query was meant, will respond with its
+ * link level address.
+ *
+ * \note This ARP implementation only supports Ethernet.
+ */
+ 
+/**
+ * \file
+ * Implementation of the ARP Address Resolution Protocol.
+ * \author Adam Dunkels <adam@dunkels.com>
+ *
+ */
+
+/*
+ * Copyright (c) 2001-2003, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uip_arp.c,v 1.5 2008/02/07 01:35:00 adamdunkels Exp $
+ *
+ */
+
+
+#include "uip_arp.h"
+
+#include <string.h>
+
+struct arp_hdr {
+  struct uip_eth_hdr ethhdr;
+  u16_t hwtype;
+  u16_t protocol;
+  u8_t hwlen;
+  u8_t protolen;
+  u16_t opcode;
+  struct uip_eth_addr shwaddr;
+  uip_ipaddr_t sipaddr;
+  struct uip_eth_addr dhwaddr;
+  uip_ipaddr_t dipaddr;
+};
+
+struct ethip_hdr {
+  struct uip_eth_hdr ethhdr;
+  /* IP header. */
+  u8_t vhl,
+    tos,
+    len[2],
+    ipid[2],
+    ipoffset[2],
+    ttl,
+    proto;
+  u16_t ipchksum;
+  uip_ipaddr_t srcipaddr, destipaddr;
+};
+
+#define ARP_REQUEST 1
+#define ARP_REPLY   2
+
+#define ARP_HWTYPE_ETH 1
+
+struct arp_entry {
+  uip_ipaddr_t ipaddr;
+  struct uip_eth_addr ethaddr;
+  u8_t time;
+};
+
+static const struct uip_eth_addr broadcast_ethaddr =
+  {{0xff,0xff,0xff,0xff,0xff,0xff}};
+static const u16_t broadcast_ipaddr[2] = {0xffff,0xffff};
+
+static struct arp_entry arp_table[UIP_ARPTAB_SIZE];
+static uip_ipaddr_t ipaddr;
+static u8_t i, c;
+
+static u8_t arptime;
+static u8_t tmpage;
+
+#define BUF   ((struct arp_hdr *)&uip_buf[0])
+#define IPBUF ((struct ethip_hdr *)&uip_buf[0])
+
+#define DEBUG 0
+#if DEBUG
+#include <stdio.h>
+#define PRINTF(...) printf(__VA_ARGS__)
+#else
+#define PRINTF(...)
+#endif
+
+/*-----------------------------------------------------------------------------------*/
+/**
+ * Initialize the ARP module.
+ *
+ */
+/*-----------------------------------------------------------------------------------*/
+void
+uip_arp_init(void)
+{
+  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+    memset(&arp_table[i].ipaddr, 0, 4);
+  }
+}
+/*-----------------------------------------------------------------------------------*/
+/**
+ * Periodic ARP processing function.
+ *
+ * This function performs periodic timer processing in the ARP module
+ * and should be called at regular intervals. The recommended interval
+ * is 10 seconds between the calls.
+ *
+ */
+/*-----------------------------------------------------------------------------------*/
+void
+uip_arp_timer(void)
+{
+  struct arp_entry *tabptr = NULL;
+  
+  ++arptime;
+  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+    tabptr = &arp_table[i];
+    if(uip_ipaddr_cmp(&tabptr->ipaddr, &uip_all_zeroes_addr) &&
+       arptime - tabptr->time >= UIP_ARP_MAXAGE) {
+      memset(&tabptr->ipaddr, 0, 4);
+    }
+  }
+
+}
+/*-----------------------------------------------------------------------------------*/
+static void
+uip_arp_update(uip_ipaddr_t *ipaddr, struct uip_eth_addr *ethaddr)
+{
+  register struct arp_entry *tabptr = NULL;
+  /* Walk through the ARP mapping table and try to find an entry to
+     update. If none is found, the IP -> MAC address mapping is
+     inserted in the ARP table. */
+  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+
+    tabptr = &arp_table[i];
+    /* Only check those entries that are actually in use. */
+    if(!uip_ipaddr_cmp(&tabptr->ipaddr, &uip_all_zeroes_addr)) {
+
+      /* Check if the source IP address of the incoming packet matches
+         the IP address in this ARP table entry. */
+      if(uip_ipaddr_cmp(ipaddr, &tabptr->ipaddr)) {
+	 
+	/* An old entry found, update this and return. */
+	memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6);
+	tabptr->time = arptime;
+
+	return;
+      }
+    }
+  }
+
+  /* If we get here, no existing ARP table entry was found, so we
+     create one. */
+
+  /* First, we try to find an unused entry in the ARP table. */
+  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+    tabptr = &arp_table[i];
+    if(uip_ipaddr_cmp(&tabptr->ipaddr, &uip_all_zeroes_addr)) {
+      break;
+    }
+  }
+
+  /* If no unused entry is found, we try to find the oldest entry and
+     throw it away. */
+  if(i == UIP_ARPTAB_SIZE) {
+    tmpage = 0;
+    c = 0;
+    for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+      tabptr = &arp_table[i];
+      if(arptime - tabptr->time > tmpage) {
+	tmpage = arptime - tabptr->time;
+	c = i;
+      }
+    }
+    i = c;
+    tabptr = &arp_table[i];
+  }
+
+  /* Now, i is the ARP table entry which we will fill with the new
+     information. */
+  uip_ipaddr_copy(&tabptr->ipaddr, ipaddr);
+  memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6);
+  tabptr->time = arptime;
+}
+/*-----------------------------------------------------------------------------------*/
+/**
+ * ARP processing for incoming IP packets
+ *
+ * This function should be called by the device driver when an IP
+ * packet has been received. The function will check if the address is
+ * in the ARP cache, and if so the ARP cache entry will be
+ * refreshed. If no ARP cache entry was found, a new one is created.
+ *
+ * This function expects an IP packet with a prepended Ethernet header
+ * in the uip_buf[] buffer, and the length of the packet in the global
+ * variable uip_len.
+ */
+/*-----------------------------------------------------------------------------------*/
+#if 0
+void
+uip_arp_ipin(void)
+{
+  uip_len -= sizeof(struct uip_eth_hdr);
+	
+  /* Only insert/update an entry if the source IP address of the
+     incoming IP packet comes from a host on the local network. */
+  if((IPBUF->srcipaddr[0] & uip_netmask[0]) !=
+     (uip_hostaddr[0] & uip_netmask[0])) {
+    return;
+  }
+  if((IPBUF->srcipaddr[1] & uip_netmask[1]) !=
+     (uip_hostaddr[1] & uip_netmask[1])) {
+    return;
+  }
+  uip_arp_update(IPBUF->srcipaddr, &(IPBUF->ethhdr.src));
+  
+  return;
+}
+#endif /* 0 */
+/*-----------------------------------------------------------------------------------*/
+/**
+ * ARP processing for incoming ARP packets.
+ *
+ * This function should be called by the device driver when an ARP
+ * packet has been received. The function will act differently
+ * depending on the ARP packet type: if it is a reply for a request
+ * that we previously sent out, the ARP cache will be filled in with
+ * the values from the ARP reply. If the incoming ARP packet is an ARP
+ * request for our IP address, an ARP reply packet is created and put
+ * into the uip_buf[] buffer.
+ *
+ * When the function returns, the value of the global variable uip_len
+ * indicates whether the device driver should send out a packet or
+ * not. If uip_len is zero, no packet should be sent. If uip_len is
+ * non-zero, it contains the length of the outbound packet that is
+ * present in the uip_buf[] buffer.
+ *
+ * This function expects an ARP packet with a prepended Ethernet
+ * header in the uip_buf[] buffer, and the length of the packet in the
+ * global variable uip_len.
+ */
+/*-----------------------------------------------------------------------------------*/
+void
+uip_arp_arpin(void)
+{
+  if(uip_len < sizeof(struct arp_hdr)) {
+    uip_len = 0;
+    return;
+  }
+  uip_len = 0;
+  
+  switch(BUF->opcode) {
+  case HTONS(ARP_REQUEST):
+    /* ARP request. If it asked for our address, we send out a
+       reply. */
+    /*    if(BUF->dipaddr[0] == uip_hostaddr[0] &&
+	  BUF->dipaddr[1] == uip_hostaddr[1]) {*/
+    PRINTF("uip_arp_arpin: request for %d.%d.%d.%d (we are %d.%d.%d.%d)\n",
+	   BUF->dipaddr.u8[0], BUF->dipaddr.u8[1],
+	   BUF->dipaddr.u8[2], BUF->dipaddr.u8[3],
+	   uip_hostaddr.u8[0], uip_hostaddr.u8[1],
+	   uip_hostaddr.u8[2], uip_hostaddr.u8[3]);
+    if(uip_ipaddr_cmp(&BUF->dipaddr, &uip_hostaddr)) {
+      /* First, we register the one who made the request in our ARP
+	 table, since it is likely that we will do more communication
+	 with this host in the future. */
+      uip_arp_update(&BUF->sipaddr, &BUF->shwaddr);
+      
+      BUF->opcode = HTONS(ARP_REPLY);
+
+      memcpy(BUF->dhwaddr.addr, BUF->shwaddr.addr, 6);
+      memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
+      memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
+      memcpy(BUF->ethhdr.dest.addr, BUF->dhwaddr.addr, 6);
+      
+      uip_ipaddr_copy(&BUF->dipaddr, &BUF->sipaddr);
+      uip_ipaddr_copy(&BUF->sipaddr, &uip_hostaddr);
+
+      BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
+      uip_len = sizeof(struct arp_hdr);
+    }
+    break;
+  case HTONS(ARP_REPLY):
+    /* ARP reply. We insert or update the ARP table if it was meant
+       for us. */
+    if(uip_ipaddr_cmp(&BUF->dipaddr, &uip_hostaddr)) {
+      uip_arp_update(&BUF->sipaddr, &BUF->shwaddr);
+    }
+    break;
+  }
+
+  return;
+}
+/*-----------------------------------------------------------------------------------*/
+/**
+ * Prepend Ethernet header to an outbound IP packet and see if we need
+ * to send out an ARP request.
+ *
+ * This function should be called before sending out an IP packet. The
+ * function checks the destination IP address of the IP packet to see
+ * what Ethernet MAC address that should be used as a destination MAC
+ * address on the Ethernet.
+ *
+ * If the destination IP address is in the local network (determined
+ * by logical ANDing of netmask and our IP address), the function
+ * checks the ARP cache to see if an entry for the destination IP
+ * address is found. If so, an Ethernet header is prepended and the
+ * function returns. If no ARP cache entry is found for the
+ * destination IP address, the packet in the uip_buf[] is replaced by
+ * an ARP request packet for the IP address. The IP packet is dropped
+ * and it is assumed that they higher level protocols (e.g., TCP)
+ * eventually will retransmit the dropped packet.
+ *
+ * If the destination IP address is not on the local network, the IP
+ * address of the default router is used instead.
+ *
+ * When the function returns, a packet is present in the uip_buf[]
+ * buffer, and the length of the packet is in the global variable
+ * uip_len.
+ */
+/*-----------------------------------------------------------------------------------*/
+void
+uip_arp_out(void)
+{
+  struct arp_entry *tabptr = NULL;
+  
+  /* Find the destination IP address in the ARP table and construct
+     the Ethernet header. If the destination IP addres isn't on the
+     local network, we use the default router's IP address instead.
+
+     If not ARP table entry is found, we overwrite the original IP
+     packet with an ARP request for the IP address. */
+
+  /* First check if destination is a local broadcast. */
+  if(uip_ipaddr_cmp(&IPBUF->destipaddr, &uip_broadcast_addr)) {
+    memcpy(IPBUF->ethhdr.dest.addr, broadcast_ethaddr.addr, 6);
+  } else {
+    /* Check if the destination address is on the local network. */
+    if(!uip_ipaddr_maskcmp(&IPBUF->destipaddr, &uip_hostaddr, &uip_netmask)) {
+      /* Destination address was not on the local network, so we need to
+	 use the default router's IP address instead of the destination
+	 address when determining the MAC address. */
+      uip_ipaddr_copy(&ipaddr, &uip_draddr);
+    } else {
+      /* Else, we use the destination IP address. */
+      uip_ipaddr_copy(&ipaddr, &IPBUF->destipaddr);
+    }
+      
+    for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+      tabptr = &arp_table[i];
+      if(uip_ipaddr_cmp(&ipaddr, &tabptr->ipaddr)) {
+	break;
+      }
+    }
+
+    if(i == UIP_ARPTAB_SIZE) {
+      /* The destination address was not in our ARP table, so we
+	 overwrite the IP packet with an ARP request. */
+
+      memset(BUF->ethhdr.dest.addr, 0xff, 6);
+      memset(BUF->dhwaddr.addr, 0x00, 6);
+      memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
+      memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
+    
+      uip_ipaddr_copy(&BUF->dipaddr, &ipaddr);
+      uip_ipaddr_copy(&BUF->sipaddr, &uip_hostaddr);
+      BUF->opcode = HTONS(ARP_REQUEST); /* ARP request. */
+      BUF->hwtype = HTONS(ARP_HWTYPE_ETH);
+      BUF->protocol = HTONS(UIP_ETHTYPE_IP);
+      BUF->hwlen = 6;
+      BUF->protolen = 4;
+      BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
+
+      uip_appdata = &uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN];
+    
+      uip_len = sizeof(struct arp_hdr);
+      return;
+    }
+
+    /* Build an ethernet header. */
+    memcpy(IPBUF->ethhdr.dest.addr, tabptr->ethaddr.addr, 6);
+  }
+  memcpy(IPBUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
+  
+  IPBUF->ethhdr.type = HTONS(UIP_ETHTYPE_IP);
+
+  uip_len += sizeof(struct uip_eth_hdr);
+}
+/*-----------------------------------------------------------------------------------*/
+
+/** @} */
+/** @} */
diff --git a/Projects/Webserver/Lib/uip/uip_arp.h b/Projects/Webserver/Lib/uip/uip_arp.h
index ea2fd293c..114d4310c 100644
--- a/Projects/Webserver/Lib/uip/uip_arp.h
+++ b/Projects/Webserver/Lib/uip/uip_arp.h
@@ -1,145 +1,145 @@
-/**

- * \addtogroup uip

- * @{

- */

-

-/**

- * \addtogroup uiparp

- * @{

- */

- 

-/**

- * \file

- * Macros and definitions for the ARP module.

- * \author Adam Dunkels <adam@dunkels.com>

- */

-  

-

-/*

- * Copyright (c) 2001-2003, Adam Dunkels.

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- * 1. Redistributions of source code must retain the above copyright

- *    notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- *    notice, this list of conditions and the following disclaimer in the

- *    documentation and/or other materials provided with the distribution.

- * 3. The name of the author may not be used to endorse or promote

- *    products derived from this software without specific prior

- *    written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS

- * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE

- * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- *

- * This file is part of the uIP TCP/IP stack.

- *

- * $Id: uip_arp.h,v 1.2 2006/08/26 23:58:45 oliverschmidt Exp $

- *

- */

-

-#ifndef __UIP_ARP_H__

-#define __UIP_ARP_H__

-

-#include "uip.h"

-

-

-extern struct uip_eth_addr uip_ethaddr;

-

-/**

- * The Ethernet header.

- */

-struct uip_eth_hdr {

-  struct uip_eth_addr dest;

-  struct uip_eth_addr src;

-  u16_t type;

-};

-

-#define UIP_ETHTYPE_ARP  0x0806

-#define UIP_ETHTYPE_IP   0x0800

-#define UIP_ETHTYPE_IPV6 0x86dd

-

-

-/* The uip_arp_init() function must be called before any of the other

-   ARP functions. */

-void uip_arp_init(void);

-

-/* The uip_arp_ipin() function should be called whenever an IP packet

-   arrives from the Ethernet. This function refreshes the ARP table or

-   inserts a new mapping if none exists. The function assumes that an

-   IP packet with an Ethernet header is present in the uip_buf buffer

-   and that the length of the packet is in the uip_len variable. */

-/*void uip_arp_ipin(void);*/

-#define uip_arp_ipin()

-

-/* The uip_arp_arpin() should be called when an ARP packet is received

-   by the Ethernet driver. This function also assumes that the

-   Ethernet frame is present in the uip_buf buffer. When the

-   uip_arp_arpin() function returns, the contents of the uip_buf

-   buffer should be sent out on the Ethernet if the uip_len variable

-   is > 0. */

-void uip_arp_arpin(void);

-

-/* The uip_arp_out() function should be called when an IP packet

-   should be sent out on the Ethernet. This function creates an

-   Ethernet header before the IP header in the uip_buf buffer. The

-   Ethernet header will have the correct Ethernet MAC destination

-   address filled in if an ARP table entry for the destination IP

-   address (or the IP address of the default router) is present. If no

-   such table entry is found, the IP packet is overwritten with an ARP

-   request and we rely on TCP to retransmit the packet that was

-   overwritten. In any case, the uip_len variable holds the length of

-   the Ethernet frame that should be transmitted. */

-void uip_arp_out(void);

-

-/* The uip_arp_timer() function should be called every ten seconds. It

-   is responsible for flushing old entries in the ARP table. */

-void uip_arp_timer(void);

-

-/** @} */

-

-/**

- * \addtogroup uipconffunc

- * @{

- */

-

-

-/**

- * Specifiy the Ethernet MAC address.

- *

- * The ARP code needs to know the MAC address of the Ethernet card in

- * order to be able to respond to ARP queries and to generate working

- * Ethernet headers.

- *

- * \note This macro only specifies the Ethernet MAC address to the ARP

- * code. It cannot be used to change the MAC address of the Ethernet

- * card.

- *

- * \param eaddr A pointer to a struct uip_eth_addr containing the

- * Ethernet MAC address of the Ethernet card.

- *

- * \hideinitializer

- */

-#define uip_setethaddr(eaddr) do {uip_ethaddr.addr[0] = eaddr.addr[0]; \

-                              uip_ethaddr.addr[1] = eaddr.addr[1];\

-                              uip_ethaddr.addr[2] = eaddr.addr[2];\

-                              uip_ethaddr.addr[3] = eaddr.addr[3];\

-                              uip_ethaddr.addr[4] = eaddr.addr[4];\

-                              uip_ethaddr.addr[5] = eaddr.addr[5];} while(0)

-

-/** @} */

-

-

-#endif /* __UIP_ARP_H__ */

-/** @} */

+/**
+ * \addtogroup uip
+ * @{
+ */
+
+/**
+ * \addtogroup uiparp
+ * @{
+ */
+ 
+/**
+ * \file
+ * Macros and definitions for the ARP module.
+ * \author Adam Dunkels <adam@dunkels.com>
+ */
+  
+
+/*
+ * Copyright (c) 2001-2003, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uip_arp.h,v 1.2 2006/08/26 23:58:45 oliverschmidt Exp $
+ *
+ */
+
+#ifndef __UIP_ARP_H__
+#define __UIP_ARP_H__
+
+#include "uip.h"
+
+
+extern struct uip_eth_addr uip_ethaddr;
+
+/**
+ * The Ethernet header.
+ */
+struct uip_eth_hdr {
+  struct uip_eth_addr dest;
+  struct uip_eth_addr src;
+  u16_t type;
+};
+
+#define UIP_ETHTYPE_ARP  0x0806
+#define UIP_ETHTYPE_IP   0x0800
+#define UIP_ETHTYPE_IPV6 0x86dd
+
+
+/* The uip_arp_init() function must be called before any of the other
+   ARP functions. */
+void uip_arp_init(void);
+
+/* The uip_arp_ipin() function should be called whenever an IP packet
+   arrives from the Ethernet. This function refreshes the ARP table or
+   inserts a new mapping if none exists. The function assumes that an
+   IP packet with an Ethernet header is present in the uip_buf buffer
+   and that the length of the packet is in the uip_len variable. */
+/*void uip_arp_ipin(void);*/
+#define uip_arp_ipin()
+
+/* The uip_arp_arpin() should be called when an ARP packet is received
+   by the Ethernet driver. This function also assumes that the
+   Ethernet frame is present in the uip_buf buffer. When the
+   uip_arp_arpin() function returns, the contents of the uip_buf
+   buffer should be sent out on the Ethernet if the uip_len variable
+   is > 0. */
+void uip_arp_arpin(void);
+
+/* The uip_arp_out() function should be called when an IP packet
+   should be sent out on the Ethernet. This function creates an
+   Ethernet header before the IP header in the uip_buf buffer. The
+   Ethernet header will have the correct Ethernet MAC destination
+   address filled in if an ARP table entry for the destination IP
+   address (or the IP address of the default router) is present. If no
+   such table entry is found, the IP packet is overwritten with an ARP
+   request and we rely on TCP to retransmit the packet that was
+   overwritten. In any case, the uip_len variable holds the length of
+   the Ethernet frame that should be transmitted. */
+void uip_arp_out(void);
+
+/* The uip_arp_timer() function should be called every ten seconds. It
+   is responsible for flushing old entries in the ARP table. */
+void uip_arp_timer(void);
+
+/** @} */
+
+/**
+ * \addtogroup uipconffunc
+ * @{
+ */
+
+
+/**
+ * Specifiy the Ethernet MAC address.
+ *
+ * The ARP code needs to know the MAC address of the Ethernet card in
+ * order to be able to respond to ARP queries and to generate working
+ * Ethernet headers.
+ *
+ * \note This macro only specifies the Ethernet MAC address to the ARP
+ * code. It cannot be used to change the MAC address of the Ethernet
+ * card.
+ *
+ * \param eaddr A pointer to a struct uip_eth_addr containing the
+ * Ethernet MAC address of the Ethernet card.
+ *
+ * \hideinitializer
+ */
+#define uip_setethaddr(eaddr) do {uip_ethaddr.addr[0] = eaddr.addr[0]; \
+                              uip_ethaddr.addr[1] = eaddr.addr[1];\
+                              uip_ethaddr.addr[2] = eaddr.addr[2];\
+                              uip_ethaddr.addr[3] = eaddr.addr[3];\
+                              uip_ethaddr.addr[4] = eaddr.addr[4];\
+                              uip_ethaddr.addr[5] = eaddr.addr[5];} while(0)
+
+/** @} */
+
+
+#endif /* __UIP_ARP_H__ */
+/** @} */
diff --git a/Projects/Webserver/Lib/uip/uipopt.h b/Projects/Webserver/Lib/uip/uipopt.h
index 7b9d19092..244ce1df1 100644
--- a/Projects/Webserver/Lib/uip/uipopt.h
+++ b/Projects/Webserver/Lib/uip/uipopt.h
@@ -1,737 +1,737 @@
-/**

- * \addtogroup uip

- * @{

- */

-

-/**

- * \defgroup uipopt Configuration options for uIP

- * @{

- *

- * uIP is configured using the per-project configuration file

- * "uipopt.h". This file contains all compile-time options for uIP and

- * should be tweaked to match each specific project. The uIP

- * distribution contains a documented example "uipopt.h" that can be

- * copied and modified for each project.

- */

-

-/**

- * \file

- * Configuration options for uIP.

- * \author Adam Dunkels <adam@dunkels.com>

- *

- * This file is used for tweaking various configuration options for

- * uIP. You should make a copy of this file into one of your project's

- * directories instead of editing this example "uipopt.h" file that

- * comes with the uIP distribution.

- */

-

-/*

- * Copyright (c) 2001-2003, Adam Dunkels.

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- * 1. Redistributions of source code must retain the above copyright

- *    notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- *    notice, this list of conditions and the following disclaimer in the

- *    documentation and/or other materials provided with the distribution.

- * 3. The name of the author may not be used to endorse or promote

- *    products derived from this software without specific prior

- *    written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS

- * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE

- * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- *

- * This file is part of the uIP TCP/IP stack.

- *

- * $Id: uipopt.h,v 1.11 2009/04/10 00:37:48 adamdunkels Exp $

- *

- */

-

-#ifndef __UIPOPT_H__

-#define __UIPOPT_H__

-

-#ifndef UIP_LITTLE_ENDIAN

-#define UIP_LITTLE_ENDIAN  3412

-#endif /* UIP_LITTLE_ENDIAN */

-#ifndef UIP_BIG_ENDIAN

-#define UIP_BIG_ENDIAN     1234

-#endif /* UIP_BIG_ENDIAN */

-

-/*------------------------------------------------------------------------------*/

-

-/**

- * \defgroup uipoptstaticconf Static configuration options

- * @{

- *

- * These configuration options can be used for setting the IP address

- * settings statically, but only if UIP_FIXEDADDR is set to 1. The

- * configuration options for a specific node includes IP address,

- * netmask and default router as well as the Ethernet address. The

- * netmask, default router and Ethernet address are applicable only

- * if uIP should be run over Ethernet.

- *

- * This options are meaningful only for the IPv4 code.

- *

- * All of these should be changed to suit your project.

- */

-

-/**

- * Determines if uIP should use a fixed IP address or not.

- *

- * If uIP should use a fixed IP address, the settings are set in the

- * uipopt.h file. If not, the macros uip_sethostaddr(),

- * uip_setdraddr() and uip_setnetmask() should be used instead.

- *

- * \hideinitializer

- */

-#define UIP_FIXEDADDR    0

-

-/**

- * Ping IP address assignment.

- *

- * uIP uses a "ping" packets for setting its own IP address if this

- * option is set. If so, uIP will start with an empty IP address and

- * the destination IP address of the first incoming "ping" (ICMP echo)

- * packet will be used for setting the hosts IP address.

- *

- * \note This works only if UIP_FIXEDADDR is 0.

- *

- * \hideinitializer

- */

-#ifdef UIP_CONF_PINGADDRCONF

-#define UIP_PINGADDRCONF UIP_CONF_PINGADDRCONF

-#else /* UIP_CONF_PINGADDRCONF */

-#define UIP_PINGADDRCONF 0

-#endif /* UIP_CONF_PINGADDRCONF */

-

-

-/**

- * Specifies if the uIP ARP module should be compiled with a fixed

- * Ethernet MAC address or not.

- *

- * If this configuration option is 0, the macro uip_setethaddr() can

- * be used to specify the Ethernet address at run-time.

- *

- * \hideinitializer

- */

-#define UIP_FIXEDETHADDR 0

-

-/** @} */

-/*------------------------------------------------------------------------------*/

-/**

- * \defgroup uipoptip IP configuration options

- * @{

- *

- */

-/**

- * The IP TTL (time to live) of IP packets sent by uIP.

- *

- * This should normally not be changed.

- */

-#define UIP_TTL         64

-

-/**

- * The maximum time an IP fragment should wait in the reassembly

- * buffer before it is dropped.

- *

- */

-#define UIP_REASS_MAXAGE 60 /*60s*/

-

-/**

- * Turn on support for IP packet reassembly.

- *

- * uIP supports reassembly of fragmented IP packets. This features

- * requires an additional amount of RAM to hold the reassembly buffer

- * and the reassembly code size is approximately 700 bytes.  The

- * reassembly buffer is of the same size as the uip_buf buffer

- * (configured by UIP_BUFSIZE).

- *

- * \note IP packet reassembly is not heavily tested.

- *

- * \hideinitializer

- */

-#ifdef UIP_CONF_REASSEMBLY

-#define UIP_REASSEMBLY UIP_CONF_REASSEMBLY

-#else /* UIP_CONF_REASSEMBLY */

-#define UIP_REASSEMBLY 0

-#endif /* UIP_CONF_REASSEMBLY */

-/** @} */

-

-/*------------------------------------------------------------------------------*/

-/**

- * \defgroup uipoptipv6 IPv6 configuration options

- * @{

- *

- */

-

-/** The maximum transmission unit at the IP Layer*/

-#define UIP_LINK_MTU 1280

-

-#ifndef UIP_CONF_IPV6

-/** Do we use IPv6 or not (default: no) */

-#define UIP_CONF_IPV6                 0

-#endif

-

-#ifndef UIP_CONF_IPV6_QUEUE_PKT

-/** Do we do per %neighbor queuing during address resolution (default: no) */

-#define UIP_CONF_IPV6_QUEUE_PKT       0

-#endif

-

-#ifndef UIP_CONF_IPV6_CHECKS 

-/** Do we do IPv6 consistency checks (highly recommended, default: yes) */

-#define UIP_CONF_IPV6_CHECKS          1

-#endif

-

-#ifndef UIP_CONF_IPV6_REASSEMBLY 

-/** Do we do IPv6 fragmentation (default: no) */

-#define UIP_CONF_IPV6_REASSEMBLY      0

-#endif

-

-#ifndef UIP_CONF_NETIF_MAX_ADDRESSES

-/** Default number of IPv6 addresses associated to the node's interface */

-#define UIP_CONF_NETIF_MAX_ADDRESSES  3

-#endif

-

-#ifndef UIP_CONF_ND6_MAX_PREFIXES 

-/** Default number of IPv6 prefixes associated to the node's interface */

-#define UIP_CONF_ND6_MAX_PREFIXES     3

-#endif

-

-#ifndef UIP_CONF_ND6_MAX_NEIGHBORS 

-/** Default number of neighbors that can be stored in the %neighbor cache */

-#define UIP_CONF_ND6_MAX_NEIGHBORS    4  

-#endif

-

-#ifndef UIP_CONF_ND6_MAX_DEFROUTERS

-/** Minimum number of default routers */

-#define UIP_CONF_ND6_MAX_DEFROUTERS   2

-#endif

-/** @} */

-

-/*------------------------------------------------------------------------------*/

-/**

- * \defgroup uipoptudp UDP configuration options

- * @{

- *

- * \note The UDP support in uIP is still not entirely complete; there

- * is no support for sending or receiving broadcast or multicast

- * packets, but it works well enough to support a number of vital

- * applications such as DNS queries, though

- */

-

-/**

- * Toggles whether UDP support should be compiled in or not.

- *

- * \hideinitializer

- */

-#ifdef UIP_CONF_UDP

-#define UIP_UDP UIP_CONF_UDP

-#else /* UIP_CONF_UDP */

-#define UIP_UDP           1

-#endif /* UIP_CONF_UDP */

-

-/**

- * Toggles if UDP checksums should be used or not.

- *

- * \note Support for UDP checksums is currently not included in uIP,

- * so this option has no function.

- *

- * \hideinitializer

- */

-#ifdef UIP_CONF_UDP_CHECKSUMS

-#define UIP_UDP_CHECKSUMS UIP_CONF_UDP_CHECKSUMS

-#else

-#define UIP_UDP_CHECKSUMS 0

-#endif

-

-/**

- * The maximum amount of concurrent UDP connections.

- *

- * \hideinitializer

- */

-#ifdef UIP_CONF_UDP_CONNS

-#define UIP_UDP_CONNS UIP_CONF_UDP_CONNS

-#else /* UIP_CONF_UDP_CONNS */

-#define UIP_UDP_CONNS    10

-#endif /* UIP_CONF_UDP_CONNS */

-

-/**

- * The name of the function that should be called when UDP datagrams arrive.

- *

- * \hideinitializer

- */

-

-

-/** @} */

-/*------------------------------------------------------------------------------*/

-/**

- * \defgroup uipopttcp TCP configuration options

- * @{

- */

-

-/**

- * Toggles whether UDP support should be compiled in or not.

- *

- * \hideinitializer

- */

-#ifdef UIP_CONF_TCP

-#define UIP_TCP UIP_CONF_TCP

-#else /* UIP_CONF_UDP */

-#define UIP_TCP           1

-#endif /* UIP_CONF_UDP */

-

-/**

- * Determines if support for opening connections from uIP should be

- * compiled in.

- *

- * If the applications that are running on top of uIP for this project

- * do not need to open outgoing TCP connections, this configuration

- * option can be turned off to reduce the code size of uIP.

- *

- * \hideinitializer

- */

-#ifndef UIP_CONF_ACTIVE_OPEN

-#define UIP_ACTIVE_OPEN 1

-#else /* UIP_CONF_ACTIVE_OPEN */

-#define UIP_ACTIVE_OPEN UIP_CONF_ACTIVE_OPEN

-#endif /* UIP_CONF_ACTIVE_OPEN */

-

-/**

- * The maximum number of simultaneously open TCP connections.

- *

- * Since the TCP connections are statically allocated, turning this

- * configuration knob down results in less RAM used. Each TCP

- * connection requires approximately 30 bytes of memory.

- *

- * \hideinitializer

- */

-#ifndef UIP_CONF_MAX_CONNECTIONS

-#define UIP_CONNS       10

-#else /* UIP_CONF_MAX_CONNECTIONS */

-#define UIP_CONNS UIP_CONF_MAX_CONNECTIONS

-#endif /* UIP_CONF_MAX_CONNECTIONS */

-

-

-/**

- * The maximum number of simultaneously listening TCP ports.

- *

- * Each listening TCP port requires 2 bytes of memory.

- *

- * \hideinitializer

- */

-#ifndef UIP_CONF_MAX_LISTENPORTS

-#define UIP_LISTENPORTS 20

-#else /* UIP_CONF_MAX_LISTENPORTS */

-#define UIP_LISTENPORTS UIP_CONF_MAX_LISTENPORTS

-#endif /* UIP_CONF_MAX_LISTENPORTS */

-

-/**

- * Determines if support for TCP urgent data notification should be

- * compiled in.

- *

- * Urgent data (out-of-band data) is a rarely used TCP feature that

- * very seldom would be required.

- *

- * \hideinitializer

- */

-#if !defined(UIP_URGDATA)

-#define UIP_URGDATA      0

-#endif

-

-/**

- * The initial retransmission timeout counted in timer pulses.

- *

- * This should not be changed.

- */

-#if !defined(UIP_RTO)

-#define UIP_RTO         3

-#endif

-

-/**

- * The maximum number of times a segment should be retransmitted

- * before the connection should be aborted.

- *

- * This should not be changed.

- */

-#if !defined(UIP_MAXRTX)

-#define UIP_MAXRTX      8

-#endif

-

-/**

- * The maximum number of times a SYN segment should be retransmitted

- * before a connection request should be deemed to have been

- * unsuccessful.

- *

- * This should not need to be changed.

- */

-#if !defined(UIP_MAXSYNRTX)

-#define UIP_MAXSYNRTX      5

-#endif

-

-/**

- * The TCP maximum segment size.

- *

- * This is should not be to set to more than

- * UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN.

- */

-#ifdef UIP_CONF_TCP_MSS

-#define UIP_TCP_MSS UIP_CONF_TCP_MSS

-#else

-#define UIP_TCP_MSS     (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)

-#endif

-

-/**

- * The size of the advertised receiver's window.

- *

- * Should be set low (i.e., to the size of the uip_buf buffer) if the

- * application is slow to process incoming data, or high (32768 bytes)

- * if the application processes data quickly.

- *

- * \hideinitializer

- */

-#ifndef UIP_CONF_RECEIVE_WINDOW

-#define UIP_RECEIVE_WINDOW UIP_TCP_MSS

-#else

-#define UIP_RECEIVE_WINDOW UIP_CONF_RECEIVE_WINDOW

-#endif

-

-/**

- * How long a connection should stay in the TIME_WAIT state.

- *

- * This configuration option has no real implication, and it should be

- * left untouched.

- */

-#define UIP_TIME_WAIT_TIMEOUT 120

-

-

-/** @} */

-/*------------------------------------------------------------------------------*/

-/**

- * \defgroup uipoptarp ARP configuration options

- * @{

- */

-

-/**

- * The size of the ARP table.

- *

- * This option should be set to a larger value if this uIP node will

- * have many connections from the local network.

- *

- * \hideinitializer

- */

-#ifdef UIP_CONF_ARPTAB_SIZE

-#define UIP_ARPTAB_SIZE UIP_CONF_ARPTAB_SIZE

-#else

-#define UIP_ARPTAB_SIZE 8

-#endif

-

-/**

- * The maximum age of ARP table entries measured in 10ths of seconds.

- *

- * An UIP_ARP_MAXAGE of 120 corresponds to 20 minutes (BSD

- * default).

- */

-#define UIP_ARP_MAXAGE 120

-

-

-/** @} */

-

-/*------------------------------------------------------------------------------*/

-

-/**

- * \defgroup uipoptmac layer 2 options (for ipv6)

- * @{

- */

-

-#define UIP_DEFAULT_PREFIX_LEN 64

-

-/** @} */

-

-/*------------------------------------------------------------------------------*/

-

-/**

- * \defgroup uipoptsics 6lowpan options (for ipv6)

- * @{

- */

-/**

- * Timeout for packet reassembly at the 6lowpan layer

- * (should be < 60s)

- */

-#ifdef SICSLOWPAN_CONF_MAXAGE

-#define SICSLOWPAN_REASS_MAXAGE SICSLOWPAN_CONF_MAXAGE

-#else

-#define SICSLOWPAN_REASS_MAXAGE 20

-#endif

-

-/**

- * Do we compress the IP header or not (default: no)

- */

-#ifndef SICSLOWPAN_CONF_COMPRESSION

-#define SICSLOWPAN_CONF_COMPRESSION 0

-#endif

-

-/**

- * If we use IPHC compression, how many address contexts do we support

- */

-#ifndef SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS 

-#define SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS 1

-#endif

-

-/**

- * Do we support 6lowpan fragmentation

- */

-#ifndef SICSLOWPAN_CONF_FRAG  

-#define SICSLOWPAN_CONF_FRAG  0

-#endif

-

-/** @} */

-

-/*------------------------------------------------------------------------------*/

-

-/**

- * \defgroup uipoptgeneral General configuration options

- * @{

- */

-

-/**

- * The size of the uIP packet buffer.

- *

- * The uIP packet buffer should not be smaller than 60 bytes, and does

- * not need to be larger than 1514 bytes. Lower size results in lower

- * TCP throughput, larger size results in higher TCP throughput.

- *

- * \hideinitializer

- */

-#ifndef UIP_CONF_BUFFER_SIZE

-#define UIP_BUFSIZE UIP_LINK_MTU + UIP_LLH_LEN

-#else /* UIP_CONF_BUFFER_SIZE */

-#define UIP_BUFSIZE UIP_CONF_BUFFER_SIZE

-#endif /* UIP_CONF_BUFFER_SIZE */

-

-

-/**

- * Determines if statistics support should be compiled in.

- *

- * The statistics is useful for debugging and to show the user.

- *

- * \hideinitializer

- */

-#ifndef UIP_CONF_STATISTICS

-#define UIP_STATISTICS  0

-#else /* UIP_CONF_STATISTICS */

-#define UIP_STATISTICS UIP_CONF_STATISTICS

-#endif /* UIP_CONF_STATISTICS */

-

-/**

- * Determines if logging of certain events should be compiled in.

- *

- * This is useful mostly for debugging. The function uip_log()

- * must be implemented to suit the architecture of the project, if

- * logging is turned on.

- *

- * \hideinitializer

- */

-#ifndef UIP_CONF_LOGGING

-#define UIP_LOGGING     0

-#else /* UIP_CONF_LOGGING */

-#define UIP_LOGGING     UIP_CONF_LOGGING

-#endif /* UIP_CONF_LOGGING */

-

-/**

- * Broadcast support.

- *

- * This flag configures IP broadcast support. This is useful only

- * together with UDP.

- *

- * \hideinitializer

- *

- */

-#ifndef UIP_CONF_BROADCAST

-#define UIP_BROADCAST 0

-#else /* UIP_CONF_BROADCAST */

-#define UIP_BROADCAST UIP_CONF_BROADCAST

-#endif /* UIP_CONF_BROADCAST */

-

-/**

- * Print out a uIP log message.

- *

- * This function must be implemented by the module that uses uIP, and

- * is called by uIP whenever a log message is generated.

- */

-void uip_log(char *msg);

-

-/**

- * The link level header length.

- *

- * This is the offset into the uip_buf where the IP header can be

- * found. For Ethernet, this should be set to 14. For SLIP, this

- * should be set to 0.

- *

- * \note we probably won't use this constant for other link layers than

- * ethernet as they have variable header length (this is due to variable

- * number and type of address fields and to optional security features)

- * E.g.: 802.15.4 -> 2 + (1/2*4/8) + 0/5/6/10/14

- *       802.11 -> 4 + (6*3/4) + 2

- * \hideinitializer

- */

-#ifdef UIP_CONF_LLH_LEN

-#define UIP_LLH_LEN UIP_CONF_LLH_LEN

-#else /* UIP_LLH_LEN */

-#define UIP_LLH_LEN     14

-#endif /* UIP_CONF_LLH_LEN */

-

-/** @} */

-/*------------------------------------------------------------------------------*/

-/**

- * \defgroup uipoptcpu CPU architecture configuration

- * @{

- *

- * The CPU architecture configuration is where the endianess of the

- * CPU on which uIP is to be run is specified. Most CPUs today are

- * little endian, and the most notable exception are the Motorolas

- * which are big endian. The BYTE_ORDER macro should be changed to

- * reflect the CPU architecture on which uIP is to be run.

- */

-

-/**

- * The byte order of the CPU architecture on which uIP is to be run.

- *

- * This option can be either UIP_BIG_ENDIAN (Motorola byte order) or

- * UIP_LITTLE_ENDIAN (Intel byte order).

- *

- * \hideinitializer

- */

-#ifdef UIP_CONF_BYTE_ORDER

-#define UIP_BYTE_ORDER     UIP_CONF_BYTE_ORDER

-#else /* UIP_CONF_BYTE_ORDER */

-#define UIP_BYTE_ORDER     UIP_LITTLE_ENDIAN

-#endif /* UIP_CONF_BYTE_ORDER */

-

-/** @} */

-/*------------------------------------------------------------------------------*/

-

-#include <ff.h>

-#include <stdbool.h>

-#include <stdint.h>

-

-#include "timer.h"

-

-typedef uint8_t u8_t;

-typedef uint16_t u16_t;

-typedef uint32_t u32_t;

-typedef uint32_t uip_stats_t;

-

-/**

- * \defgroup uipoptapp Application specific configurations

- * @{

- *

- * An uIP application is implemented using a single application

- * function that is called by uIP whenever a TCP/IP event occurs. The

- * name of this function must be registered with uIP at compile time

- * using the UIP_APPCALL definition.

- *

- * uIP applications can store the application state within the

- * uip_conn structure by specifying the type of the application

- * structure by typedef:ing the type uip_tcp_appstate_t and uip_udp_appstate_t.

- *

- * The file containing the definitions must be included in the

- * uipopt.h file.

- *

- * The following example illustrates how this can look.

- \code

-

- void httpd_appcall(void);

- #define UIP_APPCALL     httpd_appcall

-

- struct httpd_state {

- u8_t state;

- u16_t count;

- char *dataptr;

- char *script;

- };

- typedef struct httpd_state uip_tcp_appstate_t

- \endcode

-*/

-#define UIP_UDP_APPCALL uIPManagement_UDPCallback

-void UIP_UDP_APPCALL(void);

-

-/**

- * \var #define UIP_APPCALL

- *

- * The name of the application function that uIP should call in

- * response to TCP/IP events.

- *

- */

-#define UIP_APPCALL     uIPManagement_TCPCallback

-void UIP_APPCALL(void);

-

-/**

- * \var typedef uip_tcp_appstate_t

- *

- * The type of the application state that is to be stored in the

- * uip_conn structure. This usually is typedef:ed to a struct holding

- * application state information.

- */

-typedef union

-{

-	struct

-	{

-		uint8_t  CurrentState;

-		uint8_t  NextState;

-		

-		char     FileName[MAX_URI_LENGTH];

-		FIL      FileHandle;

-		bool     FileOpen;

-		uint32_t ACKedFilePos;

-		uint16_t SentChunkSize;

-	} HTTPServer;

-	

-	struct

-	{

-		uint8_t  CurrentState;

-		uint8_t  NextState;

-		

-		uint8_t  IssuedCommand;

-	} TELNETServer;

-} uip_tcp_appstate_t;

-

-/**

- * \var typedef uip_udp_appstate_t

- *

- * The type of the application state that is to be stored in the

- * uip_conn structure. This usually is typedef:ed to a struct holding

- * application state information.

- */

-typedef union

-{

-	struct

-	{

-		uint8_t      CurrentState;

-		struct timer Timeout;

-		

-		struct

-		{

-			uint8_t AllocatedIP[4];

-			uint8_t Netmask[4];

-			uint8_t GatewayIP[4];

-			uint8_t ServerIP[4];

-		} DHCPOffer_Data;

-	} DHCPClient;

-} uip_udp_appstate_t;

-/** @} */

-

-#endif /* __UIPOPT_H__ */

-/** @} */

-/** @} */

+/**
+ * \addtogroup uip
+ * @{
+ */
+
+/**
+ * \defgroup uipopt Configuration options for uIP
+ * @{
+ *
+ * uIP is configured using the per-project configuration file
+ * "uipopt.h". This file contains all compile-time options for uIP and
+ * should be tweaked to match each specific project. The uIP
+ * distribution contains a documented example "uipopt.h" that can be
+ * copied and modified for each project.
+ */
+
+/**
+ * \file
+ * Configuration options for uIP.
+ * \author Adam Dunkels <adam@dunkels.com>
+ *
+ * This file is used for tweaking various configuration options for
+ * uIP. You should make a copy of this file into one of your project's
+ * directories instead of editing this example "uipopt.h" file that
+ * comes with the uIP distribution.
+ */
+
+/*
+ * Copyright (c) 2001-2003, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uipopt.h,v 1.11 2009/04/10 00:37:48 adamdunkels Exp $
+ *
+ */
+
+#ifndef __UIPOPT_H__
+#define __UIPOPT_H__
+
+#ifndef UIP_LITTLE_ENDIAN
+#define UIP_LITTLE_ENDIAN  3412
+#endif /* UIP_LITTLE_ENDIAN */
+#ifndef UIP_BIG_ENDIAN
+#define UIP_BIG_ENDIAN     1234
+#endif /* UIP_BIG_ENDIAN */
+
+/*------------------------------------------------------------------------------*/
+
+/**
+ * \defgroup uipoptstaticconf Static configuration options
+ * @{
+ *
+ * These configuration options can be used for setting the IP address
+ * settings statically, but only if UIP_FIXEDADDR is set to 1. The
+ * configuration options for a specific node includes IP address,
+ * netmask and default router as well as the Ethernet address. The
+ * netmask, default router and Ethernet address are applicable only
+ * if uIP should be run over Ethernet.
+ *
+ * This options are meaningful only for the IPv4 code.
+ *
+ * All of these should be changed to suit your project.
+ */
+
+/**
+ * Determines if uIP should use a fixed IP address or not.
+ *
+ * If uIP should use a fixed IP address, the settings are set in the
+ * uipopt.h file. If not, the macros uip_sethostaddr(),
+ * uip_setdraddr() and uip_setnetmask() should be used instead.
+ *
+ * \hideinitializer
+ */
+#define UIP_FIXEDADDR    0
+
+/**
+ * Ping IP address assignment.
+ *
+ * uIP uses a "ping" packets for setting its own IP address if this
+ * option is set. If so, uIP will start with an empty IP address and
+ * the destination IP address of the first incoming "ping" (ICMP echo)
+ * packet will be used for setting the hosts IP address.
+ *
+ * \note This works only if UIP_FIXEDADDR is 0.
+ *
+ * \hideinitializer
+ */
+#ifdef UIP_CONF_PINGADDRCONF
+#define UIP_PINGADDRCONF UIP_CONF_PINGADDRCONF
+#else /* UIP_CONF_PINGADDRCONF */
+#define UIP_PINGADDRCONF 0
+#endif /* UIP_CONF_PINGADDRCONF */
+
+
+/**
+ * Specifies if the uIP ARP module should be compiled with a fixed
+ * Ethernet MAC address or not.
+ *
+ * If this configuration option is 0, the macro uip_setethaddr() can
+ * be used to specify the Ethernet address at run-time.
+ *
+ * \hideinitializer
+ */
+#define UIP_FIXEDETHADDR 0
+
+/** @} */
+/*------------------------------------------------------------------------------*/
+/**
+ * \defgroup uipoptip IP configuration options
+ * @{
+ *
+ */
+/**
+ * The IP TTL (time to live) of IP packets sent by uIP.
+ *
+ * This should normally not be changed.
+ */
+#define UIP_TTL         64
+
+/**
+ * The maximum time an IP fragment should wait in the reassembly
+ * buffer before it is dropped.
+ *
+ */
+#define UIP_REASS_MAXAGE 60 /*60s*/
+
+/**
+ * Turn on support for IP packet reassembly.
+ *
+ * uIP supports reassembly of fragmented IP packets. This features
+ * requires an additional amount of RAM to hold the reassembly buffer
+ * and the reassembly code size is approximately 700 bytes.  The
+ * reassembly buffer is of the same size as the uip_buf buffer
+ * (configured by UIP_BUFSIZE).
+ *
+ * \note IP packet reassembly is not heavily tested.
+ *
+ * \hideinitializer
+ */
+#ifdef UIP_CONF_REASSEMBLY
+#define UIP_REASSEMBLY UIP_CONF_REASSEMBLY
+#else /* UIP_CONF_REASSEMBLY */
+#define UIP_REASSEMBLY 0
+#endif /* UIP_CONF_REASSEMBLY */
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+/**
+ * \defgroup uipoptipv6 IPv6 configuration options
+ * @{
+ *
+ */
+
+/** The maximum transmission unit at the IP Layer*/
+#define UIP_LINK_MTU 1280
+
+#ifndef UIP_CONF_IPV6
+/** Do we use IPv6 or not (default: no) */
+#define UIP_CONF_IPV6                 0
+#endif
+
+#ifndef UIP_CONF_IPV6_QUEUE_PKT
+/** Do we do per %neighbor queuing during address resolution (default: no) */
+#define UIP_CONF_IPV6_QUEUE_PKT       0
+#endif
+
+#ifndef UIP_CONF_IPV6_CHECKS 
+/** Do we do IPv6 consistency checks (highly recommended, default: yes) */
+#define UIP_CONF_IPV6_CHECKS          1
+#endif
+
+#ifndef UIP_CONF_IPV6_REASSEMBLY 
+/** Do we do IPv6 fragmentation (default: no) */
+#define UIP_CONF_IPV6_REASSEMBLY      0
+#endif
+
+#ifndef UIP_CONF_NETIF_MAX_ADDRESSES
+/** Default number of IPv6 addresses associated to the node's interface */
+#define UIP_CONF_NETIF_MAX_ADDRESSES  3
+#endif
+
+#ifndef UIP_CONF_ND6_MAX_PREFIXES 
+/** Default number of IPv6 prefixes associated to the node's interface */
+#define UIP_CONF_ND6_MAX_PREFIXES     3
+#endif
+
+#ifndef UIP_CONF_ND6_MAX_NEIGHBORS 
+/** Default number of neighbors that can be stored in the %neighbor cache */
+#define UIP_CONF_ND6_MAX_NEIGHBORS    4  
+#endif
+
+#ifndef UIP_CONF_ND6_MAX_DEFROUTERS
+/** Minimum number of default routers */
+#define UIP_CONF_ND6_MAX_DEFROUTERS   2
+#endif
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+/**
+ * \defgroup uipoptudp UDP configuration options
+ * @{
+ *
+ * \note The UDP support in uIP is still not entirely complete; there
+ * is no support for sending or receiving broadcast or multicast
+ * packets, but it works well enough to support a number of vital
+ * applications such as DNS queries, though
+ */
+
+/**
+ * Toggles whether UDP support should be compiled in or not.
+ *
+ * \hideinitializer
+ */
+#ifdef UIP_CONF_UDP
+#define UIP_UDP UIP_CONF_UDP
+#else /* UIP_CONF_UDP */
+#define UIP_UDP           1
+#endif /* UIP_CONF_UDP */
+
+/**
+ * Toggles if UDP checksums should be used or not.
+ *
+ * \note Support for UDP checksums is currently not included in uIP,
+ * so this option has no function.
+ *
+ * \hideinitializer
+ */
+#ifdef UIP_CONF_UDP_CHECKSUMS
+#define UIP_UDP_CHECKSUMS UIP_CONF_UDP_CHECKSUMS
+#else
+#define UIP_UDP_CHECKSUMS 0
+#endif
+
+/**
+ * The maximum amount of concurrent UDP connections.
+ *
+ * \hideinitializer
+ */
+#ifdef UIP_CONF_UDP_CONNS
+#define UIP_UDP_CONNS UIP_CONF_UDP_CONNS
+#else /* UIP_CONF_UDP_CONNS */
+#define UIP_UDP_CONNS    10
+#endif /* UIP_CONF_UDP_CONNS */
+
+/**
+ * The name of the function that should be called when UDP datagrams arrive.
+ *
+ * \hideinitializer
+ */
+
+
+/** @} */
+/*------------------------------------------------------------------------------*/
+/**
+ * \defgroup uipopttcp TCP configuration options
+ * @{
+ */
+
+/**
+ * Toggles whether UDP support should be compiled in or not.
+ *
+ * \hideinitializer
+ */
+#ifdef UIP_CONF_TCP
+#define UIP_TCP UIP_CONF_TCP
+#else /* UIP_CONF_UDP */
+#define UIP_TCP           1
+#endif /* UIP_CONF_UDP */
+
+/**
+ * Determines if support for opening connections from uIP should be
+ * compiled in.
+ *
+ * If the applications that are running on top of uIP for this project
+ * do not need to open outgoing TCP connections, this configuration
+ * option can be turned off to reduce the code size of uIP.
+ *
+ * \hideinitializer
+ */
+#ifndef UIP_CONF_ACTIVE_OPEN
+#define UIP_ACTIVE_OPEN 1
+#else /* UIP_CONF_ACTIVE_OPEN */
+#define UIP_ACTIVE_OPEN UIP_CONF_ACTIVE_OPEN
+#endif /* UIP_CONF_ACTIVE_OPEN */
+
+/**
+ * The maximum number of simultaneously open TCP connections.
+ *
+ * Since the TCP connections are statically allocated, turning this
+ * configuration knob down results in less RAM used. Each TCP
+ * connection requires approximately 30 bytes of memory.
+ *
+ * \hideinitializer
+ */
+#ifndef UIP_CONF_MAX_CONNECTIONS
+#define UIP_CONNS       10
+#else /* UIP_CONF_MAX_CONNECTIONS */
+#define UIP_CONNS UIP_CONF_MAX_CONNECTIONS
+#endif /* UIP_CONF_MAX_CONNECTIONS */
+
+
+/**
+ * The maximum number of simultaneously listening TCP ports.
+ *
+ * Each listening TCP port requires 2 bytes of memory.
+ *
+ * \hideinitializer
+ */
+#ifndef UIP_CONF_MAX_LISTENPORTS
+#define UIP_LISTENPORTS 20
+#else /* UIP_CONF_MAX_LISTENPORTS */
+#define UIP_LISTENPORTS UIP_CONF_MAX_LISTENPORTS
+#endif /* UIP_CONF_MAX_LISTENPORTS */
+
+/**
+ * Determines if support for TCP urgent data notification should be
+ * compiled in.
+ *
+ * Urgent data (out-of-band data) is a rarely used TCP feature that
+ * very seldom would be required.
+ *
+ * \hideinitializer
+ */
+#if !defined(UIP_URGDATA)
+#define UIP_URGDATA      0
+#endif
+
+/**
+ * The initial retransmission timeout counted in timer pulses.
+ *
+ * This should not be changed.
+ */
+#if !defined(UIP_RTO)
+#define UIP_RTO         3
+#endif
+
+/**
+ * The maximum number of times a segment should be retransmitted
+ * before the connection should be aborted.
+ *
+ * This should not be changed.
+ */
+#if !defined(UIP_MAXRTX)
+#define UIP_MAXRTX      8
+#endif
+
+/**
+ * The maximum number of times a SYN segment should be retransmitted
+ * before a connection request should be deemed to have been
+ * unsuccessful.
+ *
+ * This should not need to be changed.
+ */
+#if !defined(UIP_MAXSYNRTX)
+#define UIP_MAXSYNRTX      5
+#endif
+
+/**
+ * The TCP maximum segment size.
+ *
+ * This is should not be to set to more than
+ * UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN.
+ */
+#ifdef UIP_CONF_TCP_MSS
+#define UIP_TCP_MSS UIP_CONF_TCP_MSS
+#else
+#define UIP_TCP_MSS     (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)
+#endif
+
+/**
+ * The size of the advertised receiver's window.
+ *
+ * Should be set low (i.e., to the size of the uip_buf buffer) if the
+ * application is slow to process incoming data, or high (32768 bytes)
+ * if the application processes data quickly.
+ *
+ * \hideinitializer
+ */
+#ifndef UIP_CONF_RECEIVE_WINDOW
+#define UIP_RECEIVE_WINDOW UIP_TCP_MSS
+#else
+#define UIP_RECEIVE_WINDOW UIP_CONF_RECEIVE_WINDOW
+#endif
+
+/**
+ * How long a connection should stay in the TIME_WAIT state.
+ *
+ * This configuration option has no real implication, and it should be
+ * left untouched.
+ */
+#define UIP_TIME_WAIT_TIMEOUT 120
+
+
+/** @} */
+/*------------------------------------------------------------------------------*/
+/**
+ * \defgroup uipoptarp ARP configuration options
+ * @{
+ */
+
+/**
+ * The size of the ARP table.
+ *
+ * This option should be set to a larger value if this uIP node will
+ * have many connections from the local network.
+ *
+ * \hideinitializer
+ */
+#ifdef UIP_CONF_ARPTAB_SIZE
+#define UIP_ARPTAB_SIZE UIP_CONF_ARPTAB_SIZE
+#else
+#define UIP_ARPTAB_SIZE 8
+#endif
+
+/**
+ * The maximum age of ARP table entries measured in 10ths of seconds.
+ *
+ * An UIP_ARP_MAXAGE of 120 corresponds to 20 minutes (BSD
+ * default).
+ */
+#define UIP_ARP_MAXAGE 120
+
+
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+
+/**
+ * \defgroup uipoptmac layer 2 options (for ipv6)
+ * @{
+ */
+
+#define UIP_DEFAULT_PREFIX_LEN 64
+
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+
+/**
+ * \defgroup uipoptsics 6lowpan options (for ipv6)
+ * @{
+ */
+/**
+ * Timeout for packet reassembly at the 6lowpan layer
+ * (should be < 60s)
+ */
+#ifdef SICSLOWPAN_CONF_MAXAGE
+#define SICSLOWPAN_REASS_MAXAGE SICSLOWPAN_CONF_MAXAGE
+#else
+#define SICSLOWPAN_REASS_MAXAGE 20
+#endif
+
+/**
+ * Do we compress the IP header or not (default: no)
+ */
+#ifndef SICSLOWPAN_CONF_COMPRESSION
+#define SICSLOWPAN_CONF_COMPRESSION 0
+#endif
+
+/**
+ * If we use IPHC compression, how many address contexts do we support
+ */
+#ifndef SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS 
+#define SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS 1
+#endif
+
+/**
+ * Do we support 6lowpan fragmentation
+ */
+#ifndef SICSLOWPAN_CONF_FRAG  
+#define SICSLOWPAN_CONF_FRAG  0
+#endif
+
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+
+/**
+ * \defgroup uipoptgeneral General configuration options
+ * @{
+ */
+
+/**
+ * The size of the uIP packet buffer.
+ *
+ * The uIP packet buffer should not be smaller than 60 bytes, and does
+ * not need to be larger than 1514 bytes. Lower size results in lower
+ * TCP throughput, larger size results in higher TCP throughput.
+ *
+ * \hideinitializer
+ */
+#ifndef UIP_CONF_BUFFER_SIZE
+#define UIP_BUFSIZE UIP_LINK_MTU + UIP_LLH_LEN
+#else /* UIP_CONF_BUFFER_SIZE */
+#define UIP_BUFSIZE UIP_CONF_BUFFER_SIZE
+#endif /* UIP_CONF_BUFFER_SIZE */
+
+
+/**
+ * Determines if statistics support should be compiled in.
+ *
+ * The statistics is useful for debugging and to show the user.
+ *
+ * \hideinitializer
+ */
+#ifndef UIP_CONF_STATISTICS
+#define UIP_STATISTICS  0
+#else /* UIP_CONF_STATISTICS */
+#define UIP_STATISTICS UIP_CONF_STATISTICS
+#endif /* UIP_CONF_STATISTICS */
+
+/**
+ * Determines if logging of certain events should be compiled in.
+ *
+ * This is useful mostly for debugging. The function uip_log()
+ * must be implemented to suit the architecture of the project, if
+ * logging is turned on.
+ *
+ * \hideinitializer
+ */
+#ifndef UIP_CONF_LOGGING
+#define UIP_LOGGING     0
+#else /* UIP_CONF_LOGGING */
+#define UIP_LOGGING     UIP_CONF_LOGGING
+#endif /* UIP_CONF_LOGGING */
+
+/**
+ * Broadcast support.
+ *
+ * This flag configures IP broadcast support. This is useful only
+ * together with UDP.
+ *
+ * \hideinitializer
+ *
+ */
+#ifndef UIP_CONF_BROADCAST
+#define UIP_BROADCAST 0
+#else /* UIP_CONF_BROADCAST */
+#define UIP_BROADCAST UIP_CONF_BROADCAST
+#endif /* UIP_CONF_BROADCAST */
+
+/**
+ * Print out a uIP log message.
+ *
+ * This function must be implemented by the module that uses uIP, and
+ * is called by uIP whenever a log message is generated.
+ */
+void uip_log(char *msg);
+
+/**
+ * The link level header length.
+ *
+ * This is the offset into the uip_buf where the IP header can be
+ * found. For Ethernet, this should be set to 14. For SLIP, this
+ * should be set to 0.
+ *
+ * \note we probably won't use this constant for other link layers than
+ * ethernet as they have variable header length (this is due to variable
+ * number and type of address fields and to optional security features)
+ * E.g.: 802.15.4 -> 2 + (1/2*4/8) + 0/5/6/10/14
+ *       802.11 -> 4 + (6*3/4) + 2
+ * \hideinitializer
+ */
+#ifdef UIP_CONF_LLH_LEN
+#define UIP_LLH_LEN UIP_CONF_LLH_LEN
+#else /* UIP_LLH_LEN */
+#define UIP_LLH_LEN     14
+#endif /* UIP_CONF_LLH_LEN */
+
+/** @} */
+/*------------------------------------------------------------------------------*/
+/**
+ * \defgroup uipoptcpu CPU architecture configuration
+ * @{
+ *
+ * The CPU architecture configuration is where the endianess of the
+ * CPU on which uIP is to be run is specified. Most CPUs today are
+ * little endian, and the most notable exception are the Motorolas
+ * which are big endian. The BYTE_ORDER macro should be changed to
+ * reflect the CPU architecture on which uIP is to be run.
+ */
+
+/**
+ * The byte order of the CPU architecture on which uIP is to be run.
+ *
+ * This option can be either UIP_BIG_ENDIAN (Motorola byte order) or
+ * UIP_LITTLE_ENDIAN (Intel byte order).
+ *
+ * \hideinitializer
+ */
+#ifdef UIP_CONF_BYTE_ORDER
+#define UIP_BYTE_ORDER     UIP_CONF_BYTE_ORDER
+#else /* UIP_CONF_BYTE_ORDER */
+#define UIP_BYTE_ORDER     UIP_LITTLE_ENDIAN
+#endif /* UIP_CONF_BYTE_ORDER */
+
+/** @} */
+/*------------------------------------------------------------------------------*/
+
+#include <ff.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "timer.h"
+
+typedef uint8_t u8_t;
+typedef uint16_t u16_t;
+typedef uint32_t u32_t;
+typedef uint32_t uip_stats_t;
+
+/**
+ * \defgroup uipoptapp Application specific configurations
+ * @{
+ *
+ * An uIP application is implemented using a single application
+ * function that is called by uIP whenever a TCP/IP event occurs. The
+ * name of this function must be registered with uIP at compile time
+ * using the UIP_APPCALL definition.
+ *
+ * uIP applications can store the application state within the
+ * uip_conn structure by specifying the type of the application
+ * structure by typedef:ing the type uip_tcp_appstate_t and uip_udp_appstate_t.
+ *
+ * The file containing the definitions must be included in the
+ * uipopt.h file.
+ *
+ * The following example illustrates how this can look.
+ \code
+
+ void httpd_appcall(void);
+ #define UIP_APPCALL     httpd_appcall
+
+ struct httpd_state {
+ u8_t state;
+ u16_t count;
+ char *dataptr;
+ char *script;
+ };
+ typedef struct httpd_state uip_tcp_appstate_t
+ \endcode
+*/
+#define UIP_UDP_APPCALL uIPManagement_UDPCallback
+void UIP_UDP_APPCALL(void);
+
+/**
+ * \var #define UIP_APPCALL
+ *
+ * The name of the application function that uIP should call in
+ * response to TCP/IP events.
+ *
+ */
+#define UIP_APPCALL     uIPManagement_TCPCallback
+void UIP_APPCALL(void);
+
+/**
+ * \var typedef uip_tcp_appstate_t
+ *
+ * The type of the application state that is to be stored in the
+ * uip_conn structure. This usually is typedef:ed to a struct holding
+ * application state information.
+ */
+typedef union
+{
+	struct
+	{
+		uint8_t  CurrentState;
+		uint8_t  NextState;
+		
+		char     FileName[MAX_URI_LENGTH];
+		FIL      FileHandle;
+		bool     FileOpen;
+		uint32_t ACKedFilePos;
+		uint16_t SentChunkSize;
+	} HTTPServer;
+	
+	struct
+	{
+		uint8_t  CurrentState;
+		uint8_t  NextState;
+		
+		uint8_t  IssuedCommand;
+	} TELNETServer;
+} uip_tcp_appstate_t;
+
+/**
+ * \var typedef uip_udp_appstate_t
+ *
+ * The type of the application state that is to be stored in the
+ * uip_conn structure. This usually is typedef:ed to a struct holding
+ * application state information.
+ */
+typedef union
+{
+	struct
+	{
+		uint8_t      CurrentState;
+		struct timer Timeout;
+		
+		struct
+		{
+			uint8_t AllocatedIP[4];
+			uint8_t Netmask[4];
+			uint8_t GatewayIP[4];
+			uint8_t ServerIP[4];
+		} DHCPOffer_Data;
+	} DHCPClient;
+} uip_udp_appstate_t;
+/** @} */
+
+#endif /* __UIPOPT_H__ */
+/** @} */
+/** @} */