summaryrefslogtreecommitdiff
path: root/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib')
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.c87
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.h78
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.c129
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.h131
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.c136
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.h111
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/EthernetProtocols.h88
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.c81
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.h82
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.c113
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.h92
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.c276
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.h60
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.c394
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.h67
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.c631
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.h260
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.c84
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.h73
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.c203
-rw-r--r--lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.h57
21 files changed, 3233 insertions, 0 deletions
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.c b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.c
new file mode 100644
index 0000000000..24008705c1
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.c
@@ -0,0 +1,87 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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
+ *
+ * Address Resolution Protocol (ARP) packet handling routines. This protocol handles the
+ * conversion of physical MAC addresses to protocol IP addresses between the host and the
+ * device.
+ */
+
+#include "ARP.h"
+
+/** Processes an ARP packet inside an Ethernet frame, and writes the appropriate response
+ * to the output Ethernet frame if the host is requesting the IP or MAC address of the
+ * virtual server device on the network.
+ *
+ * \param[in] InDataStart Pointer to the start of the incoming packet's ARP header
+ * \param[out] OutDataStart Pointer to the start of the outgoing packet's ARP header
+ *
+ * \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
+ */
+int16_t ARP_ProcessARPPacket(void* InDataStart,
+ void* OutDataStart)
+{
+ DecodeARPHeader(InDataStart);
+
+ ARP_Header_t* ARPHeaderIN = (ARP_Header_t*)InDataStart;
+ ARP_Header_t* ARPHeaderOUT = (ARP_Header_t*)OutDataStart;
+
+ /* Ensure that the ARP request is a IPv4 request packet */
+ if ((SwapEndian_16(ARPHeaderIN->ProtocolType) == ETHERTYPE_IPV4) &&
+ (SwapEndian_16(ARPHeaderIN->Operation) == ARP_OPERATION_REQUEST))
+ {
+ /* If the ARP packet is requesting the MAC or IP of the virtual webserver, return the response */
+ if (IP_COMPARE(&ARPHeaderIN->TPA, &ServerIPAddress) ||
+ MAC_COMPARE(&ARPHeaderIN->THA, &ServerMACAddress))
+ {
+ /* Fill out the ARP response header */
+ ARPHeaderOUT->HardwareType = ARPHeaderIN->HardwareType;
+ ARPHeaderOUT->ProtocolType = ARPHeaderIN->ProtocolType;
+ ARPHeaderOUT->HLEN = ARPHeaderIN->HLEN;
+ ARPHeaderOUT->PLEN = ARPHeaderIN->PLEN;
+ ARPHeaderOUT->Operation = SwapEndian_16(ARP_OPERATION_REPLY);
+
+ /* Copy over the sender MAC/IP to the target fields for the response */
+ ARPHeaderOUT->THA = ARPHeaderIN->SHA;
+ ARPHeaderOUT->TPA = ARPHeaderIN->SPA;
+
+ /* Copy over the new sender MAC/IP - MAC and IP addresses of the virtual webserver */
+ ARPHeaderOUT->SHA = ServerMACAddress;
+ ARPHeaderOUT->SPA = ServerIPAddress;
+
+ /* Return the size of the response so far */
+ return sizeof(ARP_Header_t);
+ }
+ }
+
+ return NO_RESPONSE;
+}
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.h
new file mode 100644
index 0000000000..c809cbf44a
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.h
@@ -0,0 +1,78 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 ARP.c.
+ */
+
+#ifndef _ARP_H_
+#define _ARP_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+ #include <string.h>
+
+ #include <LUFA/Drivers/USB/USB.h>
+
+ #include "EthernetProtocols.h"
+ #include "Ethernet.h"
+ #include "ProtocolDecoders.h"
+
+ /* Macros: */
+ /** ARP header operation constant, indicating a request from a host for an address translation. */
+ #define ARP_OPERATION_REQUEST 1
+
+ /** ARP header operation constant, indicating a reply from a host giving an address translation. */
+ #define ARP_OPERATION_REPLY 2
+
+ /* Type Defines: */
+ /** Type define for an ARP packet inside an Ethernet frame. */
+ typedef struct
+ {
+ uint16_t HardwareType; /**< Hardware type constant, indicating the hardware used */
+ uint16_t ProtocolType; /**< Protocol being resolved, usually ETHERTYPE_IPV4 */
+
+ uint8_t HLEN; /**< Length in bytes of the source/destination hardware addresses */
+ uint8_t PLEN; /**< Length in bytes of the source/destination protocol addresses */
+ uint16_t Operation; /**< Type of operation, either ARP_OPERATION_REQUEST or ARP_OPERATION_REPLY */
+
+ MAC_Address_t SHA; /**< Sender's hardware address */
+ IP_Address_t SPA; /**< Sender's protocol address */
+ MAC_Address_t THA; /**< Target's hardware address */
+ IP_Address_t TPA; /**< Target's protocol address */
+ } ARP_Header_t;
+
+ /* Function Prototypes: */
+ int16_t ARP_ProcessARPPacket(void* InDataStart,
+ void* OutDataStart);
+
+#endif
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.c b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.c
new file mode 100644
index 0000000000..6f7b40af69
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.c
@@ -0,0 +1,129 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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
+ *
+ * Dynamic Host Configuration Protocol (DHCP) packet handling routines. This protocol
+ * handles the automatic IP negotiation to the host, so that the host will use the provided
+ * IP address given to it by the device.
+ */
+
+#include "DHCP.h"
+
+/** Processes a DHCP packet inside an Ethernet frame, and writes the appropriate response
+ * to the output Ethernet frame if the host is requesting or accepting an IP address.
+ *
+ * \param[in] IPHeaderInStart Pointer to the start of the incoming packet's IP header
+ * \param[in] DHCPHeaderInStart Pointer to the start of the incoming packet's DHCP header
+ * \param[out] DHCPHeaderOutStart Pointer to the start of the outgoing packet's DHCP header
+ *
+ * \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
+ */
+int16_t DHCP_ProcessDHCPPacket(void* IPHeaderInStart,
+ void* DHCPHeaderInStart,
+ void* DHCPHeaderOutStart)
+{
+ IP_Header_t* IPHeaderIN = (IP_Header_t*)IPHeaderInStart;
+ DHCP_Header_t* DHCPHeaderIN = (DHCP_Header_t*)DHCPHeaderInStart;
+ DHCP_Header_t* DHCPHeaderOUT = (DHCP_Header_t*)DHCPHeaderOutStart;
+
+ uint8_t* DHCPOptionsINStart = (uint8_t*)(DHCPHeaderInStart + sizeof(DHCP_Header_t));
+ uint8_t* DHCPOptionsOUTStart = (uint8_t*)(DHCPHeaderOutStart + sizeof(DHCP_Header_t));
+
+ DecodeDHCPHeader(DHCPHeaderInStart);
+
+ /* Zero out the response DHCP packet, as much of it is legacy and left at 0 */
+ memset(DHCPHeaderOUT, 0, sizeof(DHCP_Header_t));
+
+ /* Fill out the response DHCP packet */
+ DHCPHeaderOUT->HardwareType = DHCPHeaderIN->HardwareType;
+ DHCPHeaderOUT->Operation = DHCP_OP_BOOTREPLY;
+ DHCPHeaderOUT->HardwareAddressLength = DHCPHeaderIN->HardwareAddressLength;
+ DHCPHeaderOUT->Hops = 0;
+ DHCPHeaderOUT->TransactionID = DHCPHeaderIN->TransactionID;
+ DHCPHeaderOUT->ElapsedSeconds = 0;
+ DHCPHeaderOUT->Flags = DHCPHeaderIN->Flags;
+ DHCPHeaderOUT->YourIP = ClientIPAddress;
+ memmove(&DHCPHeaderOUT->ClientHardwareAddress, &DHCPHeaderIN->ClientHardwareAddress, sizeof(MAC_Address_t));
+ DHCPHeaderOUT->Cookie = SwapEndian_32(DHCP_MAGIC_COOKIE);
+
+ /* Alter the incoming IP packet header so that the corrected IP source and destinations are used - this means that
+ when the response IP header is generated, it will use the corrected addresses and not the null/broatcast addresses */
+ IPHeaderIN->SourceAddress = ClientIPAddress;
+ IPHeaderIN->DestinationAddress = ServerIPAddress;
+
+ /* Process the incoming DHCP packet options */
+ while (DHCPOptionsINStart[0] != DHCP_OPTION_END)
+ {
+ /* Find the Message Type DHCP option, to determine the type of DHCP packet */
+ if (DHCPOptionsINStart[0] == DHCP_OPTION_MESSAGETYPE)
+ {
+ if ((DHCPOptionsINStart[2] == DHCP_MESSAGETYPE_DISCOVER) || (DHCPOptionsINStart[2] == DHCP_MESSAGETYPE_REQUEST))
+ {
+ /* Fill out the response DHCP packet options for a DHCP OFFER or ACK response */
+
+ *(DHCPOptionsOUTStart++) = DHCP_OPTION_MESSAGETYPE;
+ *(DHCPOptionsOUTStart++) = 1;
+ *(DHCPOptionsOUTStart++) = (DHCPOptionsINStart[2] == DHCP_MESSAGETYPE_DISCOVER) ? DHCP_MESSAGETYPE_OFFER
+ : DHCP_MESSAGETYPE_ACK;
+
+ *(DHCPOptionsOUTStart++) = DHCP_OPTION_SUBNETMASK;
+ *(DHCPOptionsOUTStart++) = sizeof(IP_Address_t);
+ *(DHCPOptionsOUTStart++) = 0xFF;
+ *(DHCPOptionsOUTStart++) = 0xFF;
+ *(DHCPOptionsOUTStart++) = 0xFF;
+ *(DHCPOptionsOUTStart++) = 0x00;
+
+ *(DHCPOptionsOUTStart++) = DHCP_OPTION_LEASETIME;
+ *(DHCPOptionsOUTStart++) = sizeof(uint32_t);
+ /* Lease Time 86400s (ONE_DAY) */
+ *(DHCPOptionsOUTStart++) = 0x00;
+ *(DHCPOptionsOUTStart++) = 0x01;
+ *(DHCPOptionsOUTStart++) = 0x51;
+ *(DHCPOptionsOUTStart++) = 0x80;
+
+ *(DHCPOptionsOUTStart++) = DHCP_OPTION_DHCPSERVER;
+ *(DHCPOptionsOUTStart++) = sizeof(IP_Address_t);
+ memcpy(DHCPOptionsOUTStart, &ServerIPAddress, sizeof(IP_Address_t));
+ DHCPOptionsOUTStart += sizeof(IP_Address_t);
+
+ *(DHCPOptionsOUTStart++) = DHCP_OPTION_END;
+
+ return (sizeof(DHCP_Header_t) + 18 + sizeof(IP_Address_t));
+ }
+ }
+
+ /* Go to the next DHCP option - skip one byte if option is a padding byte, else skip the complete option's size */
+ DHCPOptionsINStart += ((DHCPOptionsINStart[0] == DHCP_OPTION_PAD) ? 1 : (DHCPOptionsINStart[1] + 2));
+ }
+
+ return NO_RESPONSE;
+}
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.h
new file mode 100644
index 0000000000..5ef78469ec
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.h
@@ -0,0 +1,131 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 DHCP.c.
+ */
+
+#ifndef _DHCP_H_
+#define _DHCP_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+ #include <string.h>
+
+ #include "EthernetProtocols.h"
+ #include "Ethernet.h"
+ #include "ProtocolDecoders.h"
+
+ /* Macros: */
+ /** DHCP operation constant, indicating a request from a host to a DHCP server. */
+ #define DHCP_OP_BOOTREQUEST 0x01
+
+ /** DHCP operation constant, indicating a reply from a DHCP server to a host. */
+ #define DHCP_OP_BOOTREPLY 0x02
+
+ /** Hardware type constant, indicating Ethernet as a carrier. */
+ #define DHCP_HTYPE_ETHERNET 0x01
+
+ /** Magic boot protocol "cookie", inserted into all BOOTP packets (BOOTP is the carrier of DHCP). */
+ #define DHCP_MAGIC_COOKIE 0x63825363
+
+ /** DHCP option list entry header, indicating that a subnet mask will follow. */
+ #define DHCP_OPTION_SUBNETMASK 1
+
+ /** DHCP option list entry header, indicating that the Lease Time will follow. */
+ #define DHCP_OPTION_LEASETIME 51
+
+ /** DHCP option list entry header, indicating that the DHCP message type constant will follow. */
+ #define DHCP_OPTION_MESSAGETYPE 53
+
+ /** DHCP option list entry header, indicating that the IP address of the DHCP server will follow. */
+ #define DHCP_OPTION_DHCPSERVER 54
+
+ /** DHCP option list entry header, used to pad out option data. */
+ #define DHCP_OPTION_PAD 0
+
+ /** DHCP option list entry header, indicating the end of option data. */
+ #define DHCP_OPTION_END 255
+
+ /** Message type constant, used in the DHCP option data field, requesting that a DHCP server offer an IP address. */
+ #define DHCP_MESSAGETYPE_DISCOVER 1
+
+ /** Message type constant, used in the DHCP option data field, indicating that a DHCP server is offering an IP address. */
+ #define DHCP_MESSAGETYPE_OFFER 2
+
+ /** Message type constant, used in the DHCP option data field, requesting that a DHCP server lease a given IP address. */
+ #define DHCP_MESSAGETYPE_REQUEST 3
+
+ /** Message type constant, used in the DHCP option data field, declining an offered DHCP server IP address lease. */
+ #define DHCP_MESSAGETYPE_DECLINE 4
+
+ /** Message type constant, used in the DHCP option data field, ACKing a host IP lease request. */
+ #define DHCP_MESSAGETYPE_ACK 5
+
+ /** Message type constant, used in the DHCP option data field, NACKing a host IP lease request. */
+ #define DHCP_MESSAGETYPE_NACK 6
+
+ /** Message type constant, used in the DHCP option data field, indicating that a host is releasing a leased IP address. */
+ #define DHCP_MESSAGETYPE_RELEASE 7
+
+ /* 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 */
+
+ IP_Address_t ClientIP; /**< Client IP address, if already leased an IP */
+ IP_Address_t YourIP; /**< Client IP address */
+ IP_Address_t NextServerIP; /**< Legacy BOOTP protocol field, unused for DHCP */
+ IP_Address_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 */
+ } DHCP_Header_t;
+
+ /* Function Prototypes: */
+ int16_t DHCP_ProcessDHCPPacket(void* IPHeaderInStart,
+ void* DHCPHeaderInStart,
+ void* DHCPHeaderOutStart);
+
+#endif
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.c b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.c
new file mode 100644
index 0000000000..a48de2c717
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.c
@@ -0,0 +1,136 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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
+ *
+ * Ethernet frame packet handling routines. This protocol handles the processing of raw Ethernet
+ * frames sent and received, deferring the processing of sub-packet protocols to the appropriate
+ * protocol handlers, such as DHCP or ARP.
+ */
+
+#include "Ethernet.h"
+
+/** Ethernet Frame buffer structure, to hold the incoming Ethernet frame from the host. */
+Ethernet_Frame_Info_t FrameIN;
+
+/** Ethernet Frame buffer structure, to hold the outgoing Ethernet frame to the host. */
+Ethernet_Frame_Info_t FrameOUT;
+
+/** Constant for convenience when checking against or setting a MAC address to the virtual server MAC address. */
+const MAC_Address_t ServerMACAddress = {SERVER_MAC_ADDRESS};
+
+/** Constant for convenience when checking against or setting an IP address to the virtual server IP address. */
+const IP_Address_t ServerIPAddress = {SERVER_IP_ADDRESS};
+
+/** Constant for convenience when checking against or setting a MAC address to the broadcast MAC address. */
+const MAC_Address_t BroadcastMACAddress = {BROADCAST_MAC_ADDRESS};
+
+/** Constant for convenience when checking against or setting a IP address to the broadcast IP address. */
+const IP_Address_t BroadcastIPAddress = {BROADCAST_IP_ADDRESS};
+
+/** Constant for convenience when checking against or setting an IP address to the client (host) IP address. */
+const IP_Address_t ClientIPAddress = {CLIENT_IP_ADDRESS};
+
+
+/** Processes an incoming Ethernet frame, and writes the appropriate response to the output Ethernet
+ * frame buffer if the sub protocol handlers create a valid response.
+ */
+void Ethernet_ProcessPacket(void)
+{
+ DecodeEthernetFrameHeader(FrameIN.FrameData);
+
+ /* Cast the incoming Ethernet frame to the Ethernet header type */
+ Ethernet_Frame_Header_t* FrameINHeader = (Ethernet_Frame_Header_t*)&FrameIN.FrameData;
+ Ethernet_Frame_Header_t* FrameOUTHeader = (Ethernet_Frame_Header_t*)&FrameOUT.FrameData;
+
+ int16_t RetSize = NO_RESPONSE;
+
+ /* Ensure frame is addressed to either all (broadcast) or the virtual webserver, and is a type II frame */
+ if ((MAC_COMPARE(&FrameINHeader->Destination, &ServerMACAddress) ||
+ MAC_COMPARE(&FrameINHeader->Destination, &BroadcastMACAddress)) &&
+ (SwapEndian_16(FrameIN.FrameLength) > ETHERNET_VER2_MINSIZE))
+ {
+ /* Process the packet depending on its protocol */
+ switch (SwapEndian_16(FrameINHeader->EtherType))
+ {
+ case ETHERTYPE_ARP:
+ RetSize = ARP_ProcessARPPacket(&FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],
+ &FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);
+ break;
+ case ETHERTYPE_IPV4:
+ RetSize = IP_ProcessIPPacket(&FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],
+ &FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);
+ break;
+ }
+
+ /* Protocol processing routine has filled a response, complete the ethernet frame header */
+ if (RetSize > 0)
+ {
+ /* Fill out the response Ethernet frame header */
+ FrameOUTHeader->Source = ServerMACAddress;
+ FrameOUTHeader->Destination = FrameINHeader->Source;
+ FrameOUTHeader->EtherType = FrameINHeader->EtherType;
+
+ /* Set the response length in the buffer and indicate that a response is ready to be sent */
+ FrameOUT.FrameLength = (sizeof(Ethernet_Frame_Header_t) + RetSize);
+ }
+ }
+
+ /* Check if the packet was processed */
+ if (RetSize != NO_PROCESS)
+ {
+ /* Clear the frame buffer */
+ FrameIN.FrameLength = 0;
+ }
+}
+
+/** Calculates the appropriate ethernet checksum, consisting of the addition of the one's
+ * compliment of each word, complimented.
+ *
+ * \param[in] Data Pointer to the packet buffer data whose checksum must be calculated
+ * \param[in] Bytes Number of bytes in the data buffer to process
+ *
+ * \return A 16-bit Ethernet checksum value
+ */
+uint16_t Ethernet_Checksum16(void* Data,
+ uint16_t Bytes)
+{
+ uint16_t* Words = (uint16_t*)Data;
+ uint32_t Checksum = 0;
+
+ for (uint16_t CurrWord = 0; CurrWord < (Bytes >> 1); CurrWord++)
+ Checksum += Words[CurrWord];
+
+ while (Checksum & 0xFFFF0000)
+ Checksum = ((Checksum & 0xFFFF) + (Checksum >> 16));
+
+ return ~Checksum;
+}
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.h
new file mode 100644
index 0000000000..8eaf64080b
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.h
@@ -0,0 +1,111 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 Ethernet.c.
+ */
+
+#ifndef _ETHERNET_H_
+#define _ETHERNET_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+ #include <string.h>
+
+ #include "Config/AppConfig.h"
+
+ #include "EthernetProtocols.h"
+ #include "ProtocolDecoders.h"
+ #include "ICMP.h"
+ #include "TCP.h"
+ #include "UDP.h"
+ #include "DHCP.h"
+ #include "ARP.h"
+ #include "IP.h"
+
+ /* Macros: */
+ /** Physical MAC address of the network broadcast address. */
+ #define BROADCAST_MAC_ADDRESS {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
+
+ /** Performs a comparison between two MAC addresses, indicating if they are identical.
+ *
+ * \param[in] MAC1 First MAC address
+ * \param[in] MAC2 Second MAC address
+ *
+ * \return True if the addresses match, \c false otherwise
+ */
+ #define MAC_COMPARE(MAC1, MAC2) (memcmp(MAC1, MAC2, sizeof(MAC_Address_t)) == 0)
+
+ /** Maximum size of an incoming or outgoing Ethernet frame in bytes. */
+ #define ETHERNET_FRAME_SIZE_MAX 1500
+
+ /** Minimum size of an Ethernet packet in bytes, to conform to the Ethernet V2 packet standard. */
+ #define ETHERNET_VER2_MINSIZE 0x0600
+
+ /** Return value for all sub protocol handling routines, indicating that no response packet has been generated. */
+ #define NO_RESPONSE 0
+
+ /** Return value for all sub protocol handling routines, indicating that the packet has not yet been handled. */
+ #define NO_PROCESS -1
+
+ /* Type Defines: */
+ /** Type define for an Ethernet frame buffer data and information structure. */
+ typedef struct
+ {
+ uint8_t FrameData[ETHERNET_FRAME_SIZE_MAX]; /**< Ethernet frame contents. */
+ uint16_t FrameLength; /**< Length in bytes of the Ethernet frame stored in the buffer. */
+ } Ethernet_Frame_Info_t;
+
+ /** Type define for an Ethernet frame header. */
+ typedef struct
+ {
+ MAC_Address_t Destination; /**< Physical MAC address of the packet recipient */
+ MAC_Address_t Source; /**< Physics MAC address of the packet source */
+ uint16_t EtherType; /**< Ethernet packet sub-protocol type, for Ethernet V2 packets */
+ } Ethernet_Frame_Header_t;
+
+ /* External Variables: */
+ extern Ethernet_Frame_Info_t FrameIN;
+ extern Ethernet_Frame_Info_t FrameOUT;
+
+ extern const MAC_Address_t ServerMACAddress;
+ extern const IP_Address_t ServerIPAddress;
+ extern const MAC_Address_t BroadcastMACAddress;
+ extern const IP_Address_t BroadcastIPAddress;
+ extern const IP_Address_t ClientIPAddress;
+
+ /* Function Prototypes: */
+ void Ethernet_ProcessPacket(void);
+ uint16_t Ethernet_Checksum16(void* Data,
+ uint16_t Bytes);
+
+#endif
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/EthernetProtocols.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/EthernetProtocols.h
new file mode 100644
index 0000000000..ca738cd0db
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/EthernetProtocols.h
@@ -0,0 +1,88 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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
+ *
+ * General Ethernet protocol constants and type defines, for use by
+ * all network protocol portions of the TCP/IP stack.
+ */
+
+#ifndef _ETHERNET_PROTOCOLS_H_
+#define _ETHERNET_PROTOCOLS_H_
+
+ /* Macros: */
+ #define ETHERTYPE_IPV4 0x0800
+ #define ETHERTYPE_ARP 0x0806
+ #define ETHERTYPE_RARP 0x8035
+ #define ETHERTYPE_APPLETALK 0x809b
+ #define ETHERTYPE_APPLETALKARP 0x80f3
+ #define ETHERTYPE_IEEE8021Q 0x8100
+ #define ETHERTYPE_NOVELLIPX 0x8137
+ #define ETHERTYPE_NOVELL 0x8138
+ #define ETHERTYPE_IPV6 0x86DD
+ #define ETHERTYPE_COBRANET 0x8819
+ #define ETHERTYPE_PROVIDERBRIDGING 0x88a8
+ #define ETHERTYPE_MPLSUNICAST 0x8847
+ #define ETHERTYPE_MPLSMULTICAST 0x8848
+ #define ETHERTYPE_PPPoEDISCOVERY 0x8863
+ #define ETHERTYPE_PPPoESESSION 0x8864
+ #define ETHERTYPE_EAPOVERLAN 0x888E
+ #define ETHERTYPE_HYPERSCSI 0x889A
+ #define ETHERTYPE_ATAOVERETHERNET 0x88A2
+ #define ETHERTYPE_ETHERCAT 0x88A4
+ #define ETHERTYPE_SERCOSIII 0x88CD
+ #define ETHERTYPE_CESoE 0x88D8
+ #define ETHERTYPE_MACSECURITY 0x88E5
+ #define ETHERTYPE_FIBRECHANNEL 0x8906
+ #define ETHERTYPE_QINQ 0x9100
+ #define ETHERTYPE_VLLT 0xCAFE
+
+ #define PROTOCOL_ICMP 1
+ #define PROTOCOL_IGMP 2
+ #define PROTOCOL_TCP 6
+ #define PROTOCOL_UDP 17
+ #define PROTOCOL_OSPF 89
+ #define PROTOCOL_SCTP 132
+
+ /* Type Defines: */
+ /** Type define for a physical MAC address of a device on a network. */
+ typedef struct
+ {
+ uint8_t Octets[6]; /**< Individual bytes of a MAC address */
+ } RNDIS_MAC_Address_t;
+
+ /** Type define for a protocol IP address of a device on a network. */
+ typedef struct
+ {
+ uint8_t Octets[4]; /**< Individual bytes of an IP address */
+ } IP_Address_t;
+
+#endif
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.c b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.c
new file mode 100644
index 0000000000..b144c4c517
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.c
@@ -0,0 +1,81 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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
+ *
+ * Internet Control Message Protocol (ICMP) packet handling routines. This protocol handles
+ * Echo requests from the host, to indicate a successful network connection between the host
+ * and the virtual server.
+ */
+
+#include "ICMP.h"
+
+/** Processes an ICMP packet inside an Ethernet frame, and writes the appropriate response
+ * to the output Ethernet frame if the host is issuing a ICMP ECHO request.
+ *
+ * \param[in] InDataStart Pointer to the start of the incoming packet's ICMP header
+ * \param[out] OutDataStart Pointer to the start of the outgoing packet's ICMP header
+ *
+ * \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
+ */
+int16_t ICMP_ProcessICMPPacket(void* InDataStart,
+ void* OutDataStart)
+{
+ ICMP_Header_t* ICMPHeaderIN = (ICMP_Header_t*)InDataStart;
+ ICMP_Header_t* ICMPHeaderOUT = (ICMP_Header_t*)OutDataStart;
+
+ DecodeICMPHeader(InDataStart);
+
+ /* Determine if the ICMP packet is an echo request (ping) */
+ if (ICMPHeaderIN->Type == ICMP_TYPE_ECHOREQUEST)
+ {
+ /* Fill out the ICMP response packet */
+ ICMPHeaderOUT->Type = ICMP_TYPE_ECHOREPLY;
+ ICMPHeaderOUT->Code = 0;
+ ICMPHeaderOUT->Checksum = 0;
+ ICMPHeaderOUT->Id = ICMPHeaderIN->Id;
+ ICMPHeaderOUT->Sequence = ICMPHeaderIN->Sequence;
+
+ intptr_t DataSize = FrameIN.FrameLength - ((((intptr_t)InDataStart + sizeof(ICMP_Header_t)) - (intptr_t)FrameIN.FrameData));
+
+ /* Copy the remaining payload to the response - echo requests should echo back any sent data */
+ memmove(&((uint8_t*)OutDataStart)[sizeof(ICMP_Header_t)],
+ &((uint8_t*)InDataStart)[sizeof(ICMP_Header_t)],
+ DataSize);
+
+ ICMPHeaderOUT->Checksum = Ethernet_Checksum16(ICMPHeaderOUT, (DataSize + sizeof(ICMP_Header_t)));
+
+ /* Return the size of the response so far */
+ return (DataSize + sizeof(ICMP_Header_t));
+ }
+
+ return NO_RESPONSE;
+}
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.h
new file mode 100644
index 0000000000..e8039da3e0
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.h
@@ -0,0 +1,82 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 ICMP.c.
+ */
+
+#ifndef _ICMP_H_
+#define _ICMP_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+ #include <string.h>
+
+ #include "EthernetProtocols.h"
+ #include "Ethernet.h"
+ #include "ProtocolDecoders.h"
+
+ /* Macros: */
+ /** ICMP message type constant, indicating an ICMP ECHO Reply message. */
+ #define ICMP_TYPE_ECHOREPLY 0
+
+ /** ICMP message type constant, indicating a packet destination is unreachable. */
+ #define ICMP_TYPE_DESTINATIONUNREACHABLE 3
+
+ /** ICMP message type constant, indicating an ICMP Source Quench message. */
+ #define ICMP_TYPE_SOURCEQUENCH 4
+
+ /** ICMP message type constant, indicating an ICMP Redirect message. */
+ #define ICMP_TYPE_REDIRECTMESSAGE 5
+
+ /** ICMP message type constant, indicating an ICMP ECHO Request message. */
+ #define ICMP_TYPE_ECHOREQUEST 8
+
+ /** ICMP message type constant, indicating an ICMP Time Exceeded message. */
+ #define ICMP_TYPE_TIMEEXCEEDED 11
+
+ /* Type Defines: */
+ /** Type define for an ICMP message header. */
+ typedef struct
+ {
+ uint8_t Type; /**< ICMP message type, an \c ICMP_TYPE_* constant */
+ uint8_t Code; /**< ICMP message code, indicating the message value */
+ uint16_t Checksum; /**< Ethernet checksum of the ICMP message */
+ uint16_t Id; /**< Id of the ICMP message */
+ uint16_t Sequence; /**< Sequence number of the ICMP message, to link together message responses */
+ } ICMP_Header_t;
+
+ /* Function Prototypes: */
+ int16_t ICMP_ProcessICMPPacket(void* InDataStart,
+ void* OutDataStart);
+
+#endif
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.c b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.c
new file mode 100644
index 0000000000..dfa583b853
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.c
@@ -0,0 +1,113 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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
+ *
+ * Internet Protocol (IP) packet handling routines. This protocol handles IP packets from the
+ * host which typically encapsulate other protocols such as ICMP, UDP and TCP.
+ */
+
+#include "IP.h"
+
+/** Processes an IP packet inside an Ethernet frame, and writes the appropriate response
+ * to the output Ethernet frame if one is created by a sub-protocol handler.
+ *
+ * \param[in] InDataStart Pointer to the start of the incoming packet's IP header
+ * \param[out] OutDataStart Pointer to the start of the outgoing packet's IP header
+ *
+ * \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no
+ * response was generated, NO_PROCESS if the packet processing was deferred until the
+ * next Ethernet packet handler iteration
+ */
+int16_t IP_ProcessIPPacket(void* InDataStart,
+ void* OutDataStart)
+{
+ DecodeIPHeader(InDataStart);
+
+ IP_Header_t* IPHeaderIN = (IP_Header_t*)InDataStart;
+ IP_Header_t* IPHeaderOUT = (IP_Header_t*)OutDataStart;
+
+ /* Header length is specified in number of longs in the packet header, convert to bytes */
+ uint16_t HeaderLengthBytes = (IPHeaderIN->HeaderLength * sizeof(uint32_t));
+
+ int16_t RetSize = NO_RESPONSE;
+
+ /* Check to ensure the IP packet is addressed to the virtual webserver's IP or the broadcast IP address */
+ if (!(IP_COMPARE(&IPHeaderIN->DestinationAddress, &ServerIPAddress)) &&
+ !(IP_COMPARE(&IPHeaderIN->DestinationAddress, &BroadcastIPAddress)))
+ {
+ return NO_RESPONSE;
+ }
+
+ /* Pass off the IP payload to the appropriate protocol processing routine */
+ switch (IPHeaderIN->Protocol)
+ {
+ case PROTOCOL_ICMP:
+ RetSize = ICMP_ProcessICMPPacket(&((uint8_t*)InDataStart)[HeaderLengthBytes],
+ &((uint8_t*)OutDataStart)[sizeof(IP_Header_t)]);
+ break;
+ case PROTOCOL_TCP:
+ RetSize = TCP_ProcessTCPPacket(InDataStart,
+ &((uint8_t*)InDataStart)[HeaderLengthBytes],
+ &((uint8_t*)OutDataStart)[sizeof(IP_Header_t)]);
+ break;
+ case PROTOCOL_UDP:
+ RetSize = UDP_ProcessUDPPacket(InDataStart,
+ &((uint8_t*)InDataStart)[HeaderLengthBytes],
+ &((uint8_t*)OutDataStart)[sizeof(IP_Header_t)]);
+ break;
+ }
+
+ /* Check to see if the protocol processing routine has filled out a response */
+ if (RetSize > 0)
+ {
+ /* Fill out the response IP packet header */
+ IPHeaderOUT->TotalLength = SwapEndian_16(sizeof(IP_Header_t) + RetSize);
+ IPHeaderOUT->TypeOfService = 0;
+ IPHeaderOUT->HeaderLength = (sizeof(IP_Header_t) / sizeof(uint32_t));
+ IPHeaderOUT->Version = 4;
+ IPHeaderOUT->Flags = 0;
+ IPHeaderOUT->FragmentOffset = 0;
+ IPHeaderOUT->Identification = 0;
+ IPHeaderOUT->HeaderChecksum = 0;
+ IPHeaderOUT->Protocol = IPHeaderIN->Protocol;
+ IPHeaderOUT->TTL = DEFAULT_TTL;
+ IPHeaderOUT->SourceAddress = IPHeaderIN->DestinationAddress;
+ IPHeaderOUT->DestinationAddress = IPHeaderIN->SourceAddress;
+
+ IPHeaderOUT->HeaderChecksum = Ethernet_Checksum16(IPHeaderOUT, sizeof(IP_Header_t));
+
+ /* Return the size of the response so far */
+ return (sizeof(IP_Header_t) + RetSize);
+ }
+
+ return RetSize;
+}
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.h
new file mode 100644
index 0000000000..48f2c9086f
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.h
@@ -0,0 +1,92 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 IP.c.
+ */
+
+#ifndef _IP_H_
+#define _IP_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+ #include <string.h>
+
+ #include "EthernetProtocols.h"
+ #include "Ethernet.h"
+ #include "ProtocolDecoders.h"
+ #include "Config/AppConfig.h"
+
+ /* Macros: */
+ /** Protocol IP address of the broadcast address. */
+ #define BROADCAST_IP_ADDRESS {0xFF, 0xFF, 0xFF, 0xFF}
+
+ /** Default Time To Live (TTL) value for sent packets, indicating the maximum allowable hops until their destination
+ * is reached.
+ */
+ #define DEFAULT_TTL 128
+
+ /** Performs a comparison between two IP addresses, indicating if they are identical.
+ *
+ * \param[in] IP1 First IP address
+ * \param[in] IP2 Second IP address
+ *
+ * \return True if the addresses match, \c false otherwise
+ */
+ #define IP_COMPARE(IP1, IP2) (memcmp(IP1, IP2, sizeof(IP_Address_t)) == 0)
+
+ /* Type Defines: */
+ /** Type define of an IP packet header. */
+ typedef struct
+ {
+ unsigned HeaderLength : 4; /**< Total length of the packet header, in 4-byte blocks */
+ unsigned Version : 4; /**< IP protocol version */
+ uint8_t TypeOfService; /**< Special service type identifier, indicating delay/throughput/reliability levels */
+ uint16_t TotalLength; /**< Total length of the IP packet, in bytes */
+
+ uint16_t Identification; /**< Identification value for identifying fragmented packets */
+ unsigned FragmentOffset : 13; /**< Offset of this IP fragment */
+ unsigned Flags : 3; /**< Fragment flags, to indicate if a packet is fragmented */
+
+ uint8_t TTL; /**< Maximum allowable number of hops to reach the packet destination */
+ uint8_t Protocol; /**< Encapsulated protocol type */
+ uint16_t HeaderChecksum; /**< Ethernet checksum of the IP header */
+
+ IP_Address_t SourceAddress; /**< Source protocol IP address of the packet */
+ IP_Address_t DestinationAddress; /**< Destination protocol IP address of the packet */
+ } IP_Header_t;
+
+ /* Function Prototypes: */
+ int16_t IP_ProcessIPPacket(void* InDataStart,
+ void* OutDataStart);
+
+#endif
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.c b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.c
new file mode 100644
index 0000000000..90d678bf4b
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.c
@@ -0,0 +1,276 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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.
+*/
+
+/* Protocol decoders for Ethernet, TCP, IP, ICMP and ARP. Each of these routines
+ accepts a header to the appropriate protocol and prints out pertinent information
+ on the packet through the serial port.
+
+ To disable printing of a specific protocol, define the token NO_DECODE_{Protocol}
+ in the project makefile, and pass it to the compiler using the -D switch.
+*/
+
+/** \file
+ *
+ * Protocol decoding routines, for the plain-text decoding of Ethernet frames for debugging purposes.
+ * Enabled protocol decoders will print incoming Ethernet frame contents through the USART in a human
+ * readable format.
+ *
+ * Note that the USART is a slow transmission medium, and will slow down packet processing considerably.
+ * Packet decoding routines can be disabled by defining NO_DECODE_{Protocol Name} in the project makefile
+ * and passing it to the compiler via the -D switch.
+ */
+
+#include "ProtocolDecoders.h"
+
+/** Decodes an Ethernet frame header and prints its contents to through the USART in a human readable format.
+ *
+ * \param[in] InDataStart Pointer to the start of an Ethernet frame header
+ */
+void DecodeEthernetFrameHeader(void* InDataStart)
+{
+ #if !defined(NO_DECODE_ETHERNET)
+ Ethernet_Frame_Header_t* FrameHeader = (Ethernet_Frame_Header_t*)InDataStart;
+
+ printf_P(PSTR("\r\n"));
+
+ printf_P(PSTR(" ETHERNET\r\n"));
+
+ if (!(MAC_COMPARE(&FrameHeader->Destination, &ServerMACAddress)) &&
+ !(MAC_COMPARE(&FrameHeader->Destination, &BroadcastMACAddress)))
+ {
+ printf_P(PSTR(" + NOT ADDRESSED TO DEVICE\r\n"));
+ return;
+ }
+
+ printf_P(PSTR(" + MAC Source : %02X:%02X:%02X:%02X:%02X:%02X\r\n"), FrameHeader->Source.Octets[0],
+ FrameHeader->Source.Octets[1],
+ FrameHeader->Source.Octets[2],
+ FrameHeader->Source.Octets[3],
+ FrameHeader->Source.Octets[4],
+ FrameHeader->Source.Octets[5]);
+
+ printf_P(PSTR(" + MAC Dest: %02X:%02X:%02X:%02X:%02X:%02X\r\n"), FrameHeader->Destination.Octets[0],
+ FrameHeader->Destination.Octets[1],
+ FrameHeader->Destination.Octets[2],
+ FrameHeader->Destination.Octets[3],
+ FrameHeader->Destination.Octets[4],
+ FrameHeader->Destination.Octets[5]);
+
+ printf_P(PSTR(" + Protocol: 0x%04x\r\n"), SwapEndian_16(FrameHeader->EtherType));
+ #endif
+}
+
+/** Decodes an ARP header and prints its contents to through the USART in a human readable format.
+ *
+ * \param[in] InDataStart Pointer to the start of an ARP packet header
+ */
+void DecodeARPHeader(void* InDataStart)
+{
+ #if !defined(NO_DECODE_ARP)
+ ARP_Header_t* ARPHeader = (ARP_Header_t*)InDataStart;
+
+ printf_P(PSTR(" \\\r\n ARP\r\n"));
+
+ if (!(IP_COMPARE(&ARPHeader->TPA, &ServerIPAddress)) &&
+ !(MAC_COMPARE(&ARPHeader->THA, &ServerMACAddress)))
+ {
+ printf_P(PSTR(" + NOT ADDRESSED TO DEVICE\r\n"));
+ return;
+ }
+
+ printf_P(PSTR(" + Protocol: %x\r\n"), SwapEndian_16(ARPHeader->ProtocolType));
+ printf_P(PSTR(" + Operation: %u\r\n"), SwapEndian_16(ARPHeader->Operation));
+
+ if (SwapEndian_16(ARPHeader->ProtocolType) == ETHERTYPE_IPV4)
+ {
+ printf_P(PSTR(" + SHA MAC: %02X:%02X:%02X:%02X:%02X:%02X\r\n"), ARPHeader->SHA.Octets[0],
+ ARPHeader->SHA.Octets[1],
+ ARPHeader->SHA.Octets[2],
+ ARPHeader->SHA.Octets[3],
+ ARPHeader->SHA.Octets[4],
+ ARPHeader->SHA.Octets[5]);
+
+ printf_P(PSTR(" + SPA IP: %u.%u.%u.%u\r\n"), ARPHeader->SPA.Octets[0],
+ ARPHeader->SPA.Octets[1],
+ ARPHeader->SPA.Octets[2],
+ ARPHeader->SPA.Octets[3]);
+
+ printf_P(PSTR(" + THA MAC: %02X:%02X:%02X:%02X:%02X:%02X\r\n"), ARPHeader->THA.Octets[0],
+ ARPHeader->THA.Octets[1],
+ ARPHeader->THA.Octets[2],
+ ARPHeader->THA.Octets[3],
+ ARPHeader->THA.Octets[4],
+ ARPHeader->THA.Octets[5]);
+
+ printf_P(PSTR(" + TPA IP: %u.%u.%u.%u\r\n"), ARPHeader->TPA.Octets[0],
+ ARPHeader->TPA.Octets[1],
+ ARPHeader->TPA.Octets[2],
+ ARPHeader->TPA.Octets[3]);
+ }
+ #endif
+}
+
+/** Decodes an IP header and prints its contents to through the USART in a human readable format.
+ *
+ * \param[in] InDataStart Pointer to the start of an IP packet header
+ */
+void DecodeIPHeader(void* InDataStart)
+{
+ #if !defined(NO_DECODE_IP)
+ IP_Header_t* IPHeader = (IP_Header_t*)InDataStart;
+
+ uint16_t HeaderLengthBytes = (IPHeader->HeaderLength * sizeof(uint32_t));
+
+ printf_P(PSTR(" \\\r\n IP\r\n"));
+
+ if (!(IP_COMPARE(&IPHeader->DestinationAddress, &ServerIPAddress)))
+ {
+ printf_P(PSTR(" + NOT ADDRESSED TO DEVICE\r\n"));
+ return;
+ }
+
+ printf_P(PSTR(" + Header Length: %u Bytes\r\n"), HeaderLengthBytes);
+ printf_P(PSTR(" + Packet Version: %u\r\n"), IPHeader->Version);
+ printf_P(PSTR(" + Total Length: %u\r\n"), SwapEndian_16(IPHeader->TotalLength));
+
+ printf_P(PSTR(" + Protocol: %u\r\n"), IPHeader->Protocol);
+ printf_P(PSTR(" + TTL: %u\r\n"), IPHeader->TTL);
+
+ printf_P(PSTR(" + IP Src: %u.%u.%u.%u\r\n"), IPHeader->SourceAddress.Octets[0],
+ IPHeader->SourceAddress.Octets[1],
+ IPHeader->SourceAddress.Octets[2],
+ IPHeader->SourceAddress.Octets[3]);
+
+ printf_P(PSTR(" + IP Dst: %u.%u.%u.%u\r\n"), IPHeader->DestinationAddress.Octets[0],
+ IPHeader->DestinationAddress.Octets[1],
+ IPHeader->DestinationAddress.Octets[2],
+ IPHeader->DestinationAddress.Octets[3]);
+ #endif
+}
+
+/** Decodes an ICMP header and prints its contents to through the USART in a human readable format.
+ *
+ * \param[in] InDataStart Pointer to the start of an ICMP packet header
+ */
+void DecodeICMPHeader(void* InDataStart)
+{
+ #if !defined(NO_DECODE_ICMP)
+ ICMP_Header_t* ICMPHeader = (ICMP_Header_t*)InDataStart;
+
+ printf_P(PSTR(" \\\r\n ICMP\r\n"));
+
+ printf_P(PSTR(" + Type: %u\r\n"), ICMPHeader->Type);
+ printf_P(PSTR(" + Code: %u\r\n"), ICMPHeader->Code);
+ #endif
+}
+
+/** Decodes a TCP header and prints its contents to through the USART in a human readable format.
+ *
+ * \param[in] InDataStart Pointer to the start of a TCP packet header
+ */
+void DecodeTCPHeader(void* InDataStart)
+{
+ #if !defined(NO_DECODE_TCP)
+ TCP_Header_t* TCPHeader = (TCP_Header_t*)InDataStart;
+
+ uint16_t HeaderLengthBytes = (TCPHeader->DataOffset * sizeof(uint32_t));
+
+ printf_P(PSTR(" \\\r\n TCP\r\n"));
+
+ printf_P(PSTR(" + Header Length: %u Bytes\r\n"), HeaderLengthBytes);
+
+ printf_P(PSTR(" + Source Port: %u\r\n"), SwapEndian_16(TCPHeader->SourcePort));
+ printf_P(PSTR(" + Destination Port: %u\r\n"), SwapEndian_16(TCPHeader->DestinationPort));
+
+ printf_P(PSTR(" + Sequence Number: %lu\r\n"), SwapEndian_32(TCPHeader->SequenceNumber));
+ printf_P(PSTR(" + Acknowledgment Number: %lu\r\n"), SwapEndian_32(TCPHeader->AcknowledgmentNumber));
+
+ printf_P(PSTR(" + Flags: 0x%02X\r\n"), TCPHeader->Flags);
+
+ if (TCP_GetPortState(TCPHeader->DestinationPort) == TCP_Port_Closed)
+ printf_P(PSTR(" + NOT LISTENING ON DESTINATION PORT\r\n"));
+ #endif
+}
+
+/** Decodes an UDP header and prints its contents to through the USART in a human readable format.
+ *
+ * \param[in] InDataStart Pointer to the start of a UDP packet header
+ */
+void DecodeUDPHeader(void* InDataStart)
+{
+ #if !defined(NO_DECODE_UDP)
+ UDP_Header_t* UDPHeader = (UDP_Header_t*)InDataStart;
+
+ printf_P(PSTR(" \\\r\n UDP\r\n"));
+
+ printf_P(PSTR(" + Source Port: %u\r\n"), SwapEndian_16(UDPHeader->SourcePort));
+ printf_P(PSTR(" + Destination Port: %u\r\n"), SwapEndian_16(UDPHeader->DestinationPort));
+
+ printf_P(PSTR(" + Data Length: %d\r\n"), SwapEndian_16(UDPHeader->Length));
+ #endif
+}
+
+/** Decodes an DHCP header and prints its contents to through the USART in a human readable format.
+ *
+ * \param[in] InDataStart Pointer to the start of a DHCP packet header
+ */
+void DecodeDHCPHeader(void* InDataStart)
+{
+ #if !defined(NO_DECODE_DHCP)
+ uint8_t* DHCPOptions = ((uint8_t*)InDataStart + sizeof(DHCP_Header_t));
+
+ printf_P(PSTR(" \\\r\n DHCP\r\n"));
+
+ while (DHCPOptions[0] != DHCP_OPTION_END)
+ {
+ if (DHCPOptions[0] == DHCP_OPTION_MESSAGETYPE)
+ {
+ switch (DHCPOptions[2])
+ {
+ case DHCP_MESSAGETYPE_DISCOVER:
+ printf_P(PSTR(" + DISCOVER\r\n"));
+ break;
+ case DHCP_MESSAGETYPE_REQUEST:
+ printf_P(PSTR(" + REQUEST\r\n"));
+ break;
+ case DHCP_MESSAGETYPE_RELEASE:
+ printf_P(PSTR(" + RELEASE\r\n"));
+ break;
+ case DHCP_MESSAGETYPE_DECLINE:
+ printf_P(PSTR(" + DECLINE\r\n"));
+ break;
+ }
+ }
+
+ DHCPOptions += ((DHCPOptions[0] == DHCP_OPTION_PAD) ? 1 : (DHCPOptions[1] + 2));
+ }
+ #endif
+}
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.h
new file mode 100644
index 0000000000..77a50f02f4
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.h
@@ -0,0 +1,60 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 ProtocolDecoders.c.
+ */
+
+#ifndef _PROTOCOL_DECODERS_H_
+#define _PROTOCOL_DECODERS_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+ #include <avr/pgmspace.h>
+ #include <stdio.h>
+
+ #include <LUFA/Drivers/Peripheral/Serial.h>
+
+ #include "EthernetProtocols.h"
+ #include "Ethernet.h"
+ #include "Config/AppConfig.h"
+
+ /* Function Prototypes: */
+ void DecodeEthernetFrameHeader(void* InDataStart);
+ void DecodeARPHeader(void* InDataStart);
+ void DecodeIPHeader(void* InDataStart);
+ void DecodeICMPHeader(void* InDataStart);
+ void DecodeTCPHeader(void* InDataStart);
+ void DecodeUDPHeader(void* InDataStart);
+ void DecodeDHCPHeader(void* InDataStart);
+
+#endif
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.c b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.c
new file mode 100644
index 0000000000..00052ed39d
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.c
@@ -0,0 +1,394 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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
+ *
+ * RNDIS command handler functions. This handles RNDIS commands according to
+ * the Microsoft RNDIS specification, creating a USB Ethernet network adapter.
+ */
+
+#define INCLUDE_FROM_RNDIS_C
+#include "RNDIS.h"
+
+/** Physical MAC address of the network adapter, which becomes the MAC address of the host for packets sent to the adapter. */
+static const MAC_Address_t PROGMEM AdapterMACAddress = {ADAPTER_MAC_ADDRESS};
+
+/** Vendor description of the adapter. This is overridden by the INF file required to install the appropriate RNDIS drivers for
+ * the device, but may still be used by the OS in some circumstances.
+ */
+static const char PROGMEM AdapterVendorDescription[] = "LUFA RNDIS Adapter";
+
+/** List of RNDIS OID commands supported by this adapter. */
+static const uint32_t PROGMEM AdapterSupportedOIDList[] =
+ {
+ OID_GEN_SUPPORTED_LIST,
+ OID_GEN_PHYSICAL_MEDIUM,
+ OID_GEN_HARDWARE_STATUS,
+ OID_GEN_MEDIA_SUPPORTED,
+ OID_GEN_MEDIA_IN_USE,
+ OID_GEN_MAXIMUM_FRAME_SIZE,
+ OID_GEN_MAXIMUM_TOTAL_SIZE,
+ OID_GEN_LINK_SPEED,
+ OID_GEN_TRANSMIT_BLOCK_SIZE,
+ OID_GEN_RECEIVE_BLOCK_SIZE,
+ OID_GEN_VENDOR_ID,
+ OID_GEN_VENDOR_DESCRIPTION,
+ OID_GEN_CURRENT_PACKET_FILTER,
+ OID_GEN_MAXIMUM_TOTAL_SIZE,
+ OID_GEN_MEDIA_CONNECT_STATUS,
+ OID_GEN_XMIT_OK,
+ OID_GEN_RCV_OK,
+ OID_GEN_XMIT_ERROR,
+ OID_GEN_RCV_ERROR,
+ OID_GEN_RCV_NO_BUFFER,
+ OID_802_3_PERMANENT_ADDRESS,
+ OID_802_3_CURRENT_ADDRESS,
+ OID_802_3_MULTICAST_LIST,
+ OID_802_3_MAXIMUM_LIST_SIZE,
+ OID_802_3_RCV_ERROR_ALIGNMENT,
+ OID_802_3_XMIT_ONE_COLLISION,
+ OID_802_3_XMIT_MORE_COLLISIONS,
+ };
+
+/** Buffer for RNDIS messages (as distinct from Ethernet frames sent through the adapter. This must be big enough to hold the entire
+ * Supported OID list, plus the response header. The buffer is half-duplex, and is written to as it is read to save on SRAM - for this
+ * reason, care must be taken when constructing RNDIS responses that unread data is not overwritten when writing in responses.
+ */
+uint8_t RNDISMessageBuffer[sizeof(AdapterSupportedOIDList) + sizeof(RNDIS_Query_Complete_t)];
+
+/** Pointer to the RNDIS message header at the top of the RNDIS message buffer, for convenience. */
+RNDIS_Message_Header_t* MessageHeader = (RNDIS_Message_Header_t*)&RNDISMessageBuffer;
+
+/** Indicates if a RNDIS message response is ready to be sent back to the host. */
+bool ResponseReady = false;
+
+/** Current RNDIS adapter state, a value from the \c RNDIS_States_t enum. */
+uint8_t CurrRNDISState = RNDIS_Uninitialized;
+
+/** Current Ethernet packet filter mask. This is non-zero when the adapter is initialized, or zero when disabled. */
+uint32_t CurrPacketFilter = 0;
+
+
+/** Processes the RNDIS message received by the host and stored in the RNDISMessageBuffer global buffer. If a response is
+ * created, the ResponseReady global is updated so that the response is written back to the host upon request.
+ */
+void ProcessRNDISControlMessage(void)
+{
+ /* Note: Only a single buffer is used for both the received message and its response to save SRAM. Because of
+ this, response bytes should be filled in order so that they do not clobber unread data in the buffer. */
+
+ switch (MessageHeader->MessageType)
+ {
+ case REMOTE_NDIS_INITIALIZE_MSG:
+ /* Initialize the adapter - return information about the supported RNDIS version and buffer sizes */
+
+ ResponseReady = true;
+
+ RNDIS_Initialize_Message_t* INITIALIZE_Message = (RNDIS_Initialize_Message_t*)&RNDISMessageBuffer;
+ RNDIS_Initialize_Complete_t* INITIALIZE_Response = (RNDIS_Initialize_Complete_t*)&RNDISMessageBuffer;
+
+ INITIALIZE_Response->MessageType = REMOTE_NDIS_INITIALIZE_CMPLT;
+ INITIALIZE_Response->MessageLength = sizeof(RNDIS_Initialize_Complete_t);
+ INITIALIZE_Response->RequestId = INITIALIZE_Message->RequestId;
+ INITIALIZE_Response->Status = REMOTE_NDIS_STATUS_SUCCESS;
+
+ INITIALIZE_Response->MajorVersion = REMOTE_NDIS_VERSION_MAJOR;
+ INITIALIZE_Response->MinorVersion = REMOTE_NDIS_VERSION_MINOR;
+ INITIALIZE_Response->DeviceFlags = REMOTE_NDIS_DF_CONNECTIONLESS;
+ INITIALIZE_Response->Medium = REMOTE_NDIS_MEDIUM_802_3;
+ INITIALIZE_Response->MaxPacketsPerTransfer = 1;
+ INITIALIZE_Response->MaxTransferSize = (sizeof(RNDIS_Packet_Message_t) + ETHERNET_FRAME_SIZE_MAX);
+ INITIALIZE_Response->PacketAlignmentFactor = 0;
+ INITIALIZE_Response->AFListOffset = 0;
+ INITIALIZE_Response->AFListSize = 0;
+
+ CurrRNDISState = RNDIS_Initialized;
+
+ break;
+ case REMOTE_NDIS_HALT_MSG:
+ /* Halt the adapter, reset the adapter state - note that no response should be returned when completed */
+
+ ResponseReady = false;
+ MessageHeader->MessageLength = 0;
+
+ CurrRNDISState = RNDIS_Uninitialized;
+
+ break;
+ case REMOTE_NDIS_QUERY_MSG:
+ /* Request for information about a parameter about the adapter, specified as an OID token */
+
+ ResponseReady = true;
+
+ RNDIS_Query_Message_t* QUERY_Message = (RNDIS_Query_Message_t*)&RNDISMessageBuffer;
+ RNDIS_Query_Complete_t* QUERY_Response = (RNDIS_Query_Complete_t*)&RNDISMessageBuffer;
+ uint32_t Query_Oid = QUERY_Message->Oid;
+
+ void* QueryData = &RNDISMessageBuffer[sizeof(RNDIS_Message_Header_t) +
+ QUERY_Message->InformationBufferOffset];
+ void* ResponseData = &RNDISMessageBuffer[sizeof(RNDIS_Query_Complete_t)];
+ uint16_t ResponseSize;
+
+ QUERY_Response->MessageType = REMOTE_NDIS_QUERY_CMPLT;
+ QUERY_Response->MessageLength = sizeof(RNDIS_Query_Complete_t);
+
+ if (ProcessNDISQuery(Query_Oid, QueryData, QUERY_Message->InformationBufferLength,
+ ResponseData, &ResponseSize))
+ {
+ QUERY_Response->Status = REMOTE_NDIS_STATUS_SUCCESS;
+ QUERY_Response->MessageLength += ResponseSize;
+
+ QUERY_Response->InformationBufferLength = ResponseSize;
+ QUERY_Response->InformationBufferOffset = (sizeof(RNDIS_Query_Complete_t) - sizeof(RNDIS_Message_Header_t));
+ }
+ else
+ {
+ QUERY_Response->Status = REMOTE_NDIS_STATUS_NOT_SUPPORTED;
+
+ QUERY_Response->InformationBufferLength = 0;
+ QUERY_Response->InformationBufferOffset = 0;
+ }
+
+ break;
+ case REMOTE_NDIS_SET_MSG:
+ /* Request to set a parameter of the adapter, specified as an OID token */
+
+ ResponseReady = true;
+
+ RNDIS_Set_Message_t* SET_Message = (RNDIS_Set_Message_t*)&RNDISMessageBuffer;
+ RNDIS_Set_Complete_t* SET_Response = (RNDIS_Set_Complete_t*)&RNDISMessageBuffer;
+ uint32_t SET_Oid = SET_Message->Oid;
+
+ SET_Response->MessageType = REMOTE_NDIS_SET_CMPLT;
+ SET_Response->MessageLength = sizeof(RNDIS_Set_Complete_t);
+ SET_Response->RequestId = SET_Message->RequestId;
+
+ void* SetData = &RNDISMessageBuffer[sizeof(RNDIS_Message_Header_t) +
+ SET_Message->InformationBufferOffset];
+
+ if (ProcessNDISSet(SET_Oid, SetData, SET_Message->InformationBufferLength))
+ SET_Response->Status = REMOTE_NDIS_STATUS_SUCCESS;
+ else
+ SET_Response->Status = REMOTE_NDIS_STATUS_NOT_SUPPORTED;
+
+ break;
+ case REMOTE_NDIS_RESET_MSG:
+ /* Soft reset the adapter */
+
+ ResponseReady = true;
+
+ RNDIS_Reset_Complete_t* RESET_Response = (RNDIS_Reset_Complete_t*)&RNDISMessageBuffer;
+
+ RESET_Response->MessageType = REMOTE_NDIS_RESET_CMPLT;
+ RESET_Response->MessageLength = sizeof(RNDIS_Reset_Complete_t);
+ RESET_Response->Status = REMOTE_NDIS_STATUS_SUCCESS;
+ RESET_Response->AddressingReset = 0;
+
+ break;
+ case REMOTE_NDIS_KEEPALIVE_MSG:
+ /* Keep alive message sent to the adapter every 5 seconds when idle to ensure it is still responding */
+
+ ResponseReady = true;
+
+ RNDIS_KeepAlive_Message_t* KEEPALIVE_Message = (RNDIS_KeepAlive_Message_t*)&RNDISMessageBuffer;
+ RNDIS_KeepAlive_Complete_t* KEEPALIVE_Response = (RNDIS_KeepAlive_Complete_t*)&RNDISMessageBuffer;
+
+ KEEPALIVE_Response->MessageType = REMOTE_NDIS_KEEPALIVE_CMPLT;
+ KEEPALIVE_Response->MessageLength = sizeof(RNDIS_KeepAlive_Complete_t);
+ KEEPALIVE_Response->RequestId = KEEPALIVE_Message->RequestId;
+ KEEPALIVE_Response->Status = REMOTE_NDIS_STATUS_SUCCESS;
+
+ break;
+ }
+}
+
+/** Processes RNDIS query commands, retrieving information from the adapter and reporting it back to the host. The requested
+ * parameter is given as an OID value.
+ *
+ * \param[in] OId OId value of the parameter being queried
+ * \param[in] QueryData Pointer to any extra query data being sent by the host to the device inside the RNDIS message buffer
+ * \param[in] QuerySize Size in bytes of the extra query data being sent by the host
+ * \param[out] ResponseData Pointer to the start of the query response inside the RNDIS message buffer
+ * \param[out] ResponseSize Pointer to the size in bytes of the response data being sent to the host
+ *
+ * \return Boolean \c true if the query was handled, \c false otherwise
+ */
+static bool ProcessNDISQuery(const uint32_t OId, void* QueryData, uint16_t QuerySize,
+ void* ResponseData, uint16_t* ResponseSize)
+{
+ /* Handler for REMOTE_NDIS_QUERY_MSG messages */
+
+ switch (OId)
+ {
+ case OID_GEN_SUPPORTED_LIST:
+ *ResponseSize = sizeof(AdapterSupportedOIDList);
+
+ /* Copy the list of supported NDIS OID tokens to the response buffer */
+ memcpy_P(ResponseData, AdapterSupportedOIDList, sizeof(AdapterSupportedOIDList));
+
+ return true;
+ case OID_GEN_PHYSICAL_MEDIUM:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Indicate that the device is a true ethernet link */
+ *((uint32_t*)ResponseData) = 0;
+
+ return true;
+ case OID_GEN_HARDWARE_STATUS:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Always indicate hardware ready */
+ *((uint32_t*)ResponseData) = NDIS_HardwareStatus_Ready;
+
+ return true;
+ case OID_GEN_MEDIA_SUPPORTED:
+ case OID_GEN_MEDIA_IN_USE:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Indicate 802.3 (Ethernet) supported by the adapter */
+ *((uint32_t*)ResponseData) = REMOTE_NDIS_MEDIUM_802_3;
+
+ return true;
+ case OID_GEN_VENDOR_ID:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Vendor ID 0x0xFFFFFF is reserved for vendors who have not purchased a NDIS VID */
+ *((uint32_t*)ResponseData) = 0x00FFFFFF;
+
+ return true;
+ case OID_GEN_MAXIMUM_FRAME_SIZE:
+ case OID_GEN_TRANSMIT_BLOCK_SIZE:
+ case OID_GEN_RECEIVE_BLOCK_SIZE:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Indicate that the maximum frame size is the size of the ethernet frame buffer */
+ *((uint32_t*)ResponseData) = ETHERNET_FRAME_SIZE_MAX;
+
+ return true;
+ case OID_GEN_VENDOR_DESCRIPTION:
+ *ResponseSize = sizeof(AdapterVendorDescription);
+
+ /* Copy vendor description string to the response buffer */
+ memcpy_P(ResponseData, AdapterVendorDescription, sizeof(AdapterVendorDescription));
+
+ return true;
+ case OID_GEN_MEDIA_CONNECT_STATUS:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Always indicate that the adapter is connected to a network */
+ *((uint32_t*)ResponseData) = REMOTE_NDIS_MEDIA_STATE_CONNECTED;
+
+ return true;
+ case OID_GEN_LINK_SPEED:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Indicate 10Mb/s link speed */
+ *((uint32_t*)ResponseData) = 100000;
+
+ return true;
+ case OID_802_3_PERMANENT_ADDRESS:
+ case OID_802_3_CURRENT_ADDRESS:
+ *ResponseSize = sizeof(MAC_Address_t);
+
+ /* Copy over the fixed adapter MAC to the response buffer */
+ memcpy_P(ResponseData, &AdapterMACAddress, sizeof(MAC_Address_t));
+
+ return true;
+ case OID_802_3_MAXIMUM_LIST_SIZE:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Indicate only one multicast address supported */
+ *((uint32_t*)ResponseData) = 1;
+
+ return true;
+ case OID_GEN_CURRENT_PACKET_FILTER:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Indicate the current packet filter mask */
+ *((uint32_t*)ResponseData) = CurrPacketFilter;
+
+ return true;
+ case OID_GEN_XMIT_OK:
+ case OID_GEN_RCV_OK:
+ case OID_GEN_XMIT_ERROR:
+ case OID_GEN_RCV_ERROR:
+ case OID_GEN_RCV_NO_BUFFER:
+ case OID_802_3_RCV_ERROR_ALIGNMENT:
+ case OID_802_3_XMIT_ONE_COLLISION:
+ case OID_802_3_XMIT_MORE_COLLISIONS:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Unused statistic OIDs - always return 0 for each */
+ *((uint32_t*)ResponseData) = 0;
+
+ return true;
+ case OID_GEN_MAXIMUM_TOTAL_SIZE:
+ *ResponseSize = sizeof(uint32_t);
+
+ /* Indicate maximum overall buffer (Ethernet frame and RNDIS header) the adapter can handle */
+ *((uint32_t*)ResponseData) = (sizeof(RNDISMessageBuffer) + ETHERNET_FRAME_SIZE_MAX);
+
+ return true;
+ default:
+ return false;
+ }
+}
+
+/** Processes RNDIS set commands, setting adapter parameters to values given by the host. The requested parameter is given
+ * as an OID value.
+ *
+ * \param[in] OId OId value of the parameter being set
+ * \param[in] SetData Pointer to the parameter value in the RNDIS message buffer
+ * \param[in] SetSize Size in bytes of the parameter value being sent by the host
+ *
+ * \return Boolean \c true if the set was handled, \c false otherwise
+ */
+static bool ProcessNDISSet(uint32_t OId, void* SetData, uint16_t SetSize)
+{
+ /* Handler for REMOTE_NDIS_SET_MSG messages */
+
+ switch (OId)
+ {
+ case OID_GEN_CURRENT_PACKET_FILTER:
+ /* Save the packet filter mask in case the host queries it again later */
+ CurrPacketFilter = *((uint32_t*)SetData);
+
+ /* Set the RNDIS state to initialized if the packet filter is non-zero */
+ CurrRNDISState = ((CurrPacketFilter) ? RNDIS_Data_Initialized : RNDIS_Initialized);
+
+ return true;
+ case OID_802_3_MULTICAST_LIST:
+ /* Do nothing - throw away the value from the host as it is unused */
+
+ return true;
+ default:
+ return false;
+ }
+}
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.h
new file mode 100644
index 0000000000..bea97f79df
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.h
@@ -0,0 +1,67 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 RNDIS.c.
+ */
+
+#ifndef _RNDIS_H_
+#define _RNDIS_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+ #include <stdbool.h>
+
+ #include "../RNDISEthernet.h"
+ #include "Ethernet.h"
+
+ /* External Variables: */
+ extern uint8_t RNDISMessageBuffer[];
+ extern RNDIS_Message_Header_t* MessageHeader;
+ extern bool ResponseReady;
+ extern uint8_t CurrRNDISState;
+
+ /* Function Prototypes: */
+ void ProcessRNDISControlMessage(void);
+
+ #if defined(INCLUDE_FROM_RNDIS_C)
+ static bool ProcessNDISQuery(const uint32_t OId,
+ void* QueryData,
+ uint16_t QuerySize,
+ void* ResponseData,
+ uint16_t* ResponseSize);
+ static bool ProcessNDISSet(const uint32_t OId,
+ void* SetData,
+ uint16_t SetSize);
+ #endif
+
+#endif
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.c b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.c
new file mode 100644
index 0000000000..a6f1f6adfc
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.c
@@ -0,0 +1,631 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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
+ *
+ * Transmission Control Protocol (TCP) packet handling routines. This protocol handles the reliable in-order transmission
+ * and reception of packets to and from devices on a network, to "ports" on the device. It is used in situations where data
+ * delivery must be reliable and correct, e.g. HTTP, TELNET and most other non-streaming protocols.
+ */
+
+#define INCLUDE_FROM_TCP_C
+#include "TCP.h"
+
+/** Port state table array. This contains the current status of TCP ports in the device. To save on space, only open ports are
+ * stored - closed ports may be overwritten at any time, and the system will assume any ports not present in the array are closed. This
+ * allows for MAX_OPEN_TCP_PORTS to be less than the number of ports used by the application if desired.
+ */
+TCP_PortState_t PortStateTable[MAX_OPEN_TCP_PORTS];
+
+/** Connection state table array. This contains the current status of TCP connections in the device. To save on space, only active
+ * (non-closed) connections are stored - closed connections may be overwritten at any time, and the system will assume any connections
+ * not present in the array are closed.
+ */
+TCP_ConnectionState_t ConnectionStateTable[MAX_TCP_CONNECTIONS];
+
+
+/** Task to handle the calling of each registered application's callback function, to process and generate TCP packets at the application
+ * level. If an application produces a response, this task constructs the appropriate Ethernet frame and places it into the Ethernet OUT
+ * buffer for later transmission.
+ */
+void TCP_Task(void)
+{
+ /* Run each application in sequence, to process incoming and generate outgoing packets */
+ for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
+ {
+ /* Find the corresponding port entry in the port table */
+ for (uint8_t PTableEntry = 0; PTableEntry < MAX_OPEN_TCP_PORTS; PTableEntry++)
+ {
+ /* Run the application handler for the port */
+ if ((PortStateTable[PTableEntry].Port == ConnectionStateTable[CSTableEntry].Port) &&
+ (PortStateTable[PTableEntry].State == TCP_Port_Open))
+ {
+ PortStateTable[PTableEntry].ApplicationHandler(&ConnectionStateTable[CSTableEntry],
+ &ConnectionStateTable[CSTableEntry].Info.Buffer);
+ }
+ }
+ }
+
+ /* Bail out early if there is already a frame waiting to be sent in the Ethernet OUT buffer */
+ if (FrameOUT.FrameLength)
+ return;
+
+ /* Send response packets from each application as the TCP packet buffers are filled by the applications */
+ for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
+ {
+ /* For each completely received packet, pass it along to the listening application */
+ if ((ConnectionStateTable[CSTableEntry].Info.Buffer.Direction == TCP_PACKETDIR_OUT) &&
+ (ConnectionStateTable[CSTableEntry].Info.Buffer.Ready))
+ {
+ Ethernet_Frame_Header_t* FrameOUTHeader = (Ethernet_Frame_Header_t*)&FrameOUT.FrameData;
+ IP_Header_t* IPHeaderOUT = (IP_Header_t*)&FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)];
+ TCP_Header_t* TCPHeaderOUT = (TCP_Header_t*)&FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t) +
+ sizeof(IP_Header_t)];
+ void* TCPDataOUT = &FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t) +
+ sizeof(IP_Header_t) +
+ sizeof(TCP_Header_t)];
+
+ uint16_t PacketSize = ConnectionStateTable[CSTableEntry].Info.Buffer.Length;
+
+ /* Fill out the TCP data */
+ TCPHeaderOUT->SourcePort = ConnectionStateTable[CSTableEntry].Port;
+ TCPHeaderOUT->DestinationPort = ConnectionStateTable[CSTableEntry].RemotePort;
+ TCPHeaderOUT->SequenceNumber = SwapEndian_32(ConnectionStateTable[CSTableEntry].Info.SequenceNumberOut);
+ TCPHeaderOUT->AcknowledgmentNumber = SwapEndian_32(ConnectionStateTable[CSTableEntry].Info.SequenceNumberIn);
+ TCPHeaderOUT->DataOffset = (sizeof(TCP_Header_t) / sizeof(uint32_t));
+ TCPHeaderOUT->WindowSize = SwapEndian_16(TCP_WINDOW_SIZE);
+
+ TCPHeaderOUT->Flags = TCP_FLAG_ACK;
+ TCPHeaderOUT->UrgentPointer = 0;
+ TCPHeaderOUT->Checksum = 0;
+ TCPHeaderOUT->Reserved = 0;
+
+ memcpy(TCPDataOUT, ConnectionStateTable[CSTableEntry].Info.Buffer.Data, PacketSize);
+
+ ConnectionStateTable[CSTableEntry].Info.SequenceNumberOut += PacketSize;
+
+ TCPHeaderOUT->Checksum = TCP_Checksum16(TCPHeaderOUT, &ServerIPAddress,
+ &ConnectionStateTable[CSTableEntry].RemoteAddress,
+ (sizeof(TCP_Header_t) + PacketSize));
+
+ PacketSize += sizeof(TCP_Header_t);
+
+ /* Fill out the response IP header */
+ IPHeaderOUT->TotalLength = SwapEndian_16(sizeof(IP_Header_t) + PacketSize);
+ IPHeaderOUT->TypeOfService = 0;
+ IPHeaderOUT->HeaderLength = (sizeof(IP_Header_t) / sizeof(uint32_t));
+ IPHeaderOUT->Version = 4;
+ IPHeaderOUT->Flags = 0;
+ IPHeaderOUT->FragmentOffset = 0;
+ IPHeaderOUT->Identification = 0;
+ IPHeaderOUT->HeaderChecksum = 0;
+ IPHeaderOUT->Protocol = PROTOCOL_TCP;
+ IPHeaderOUT->TTL = DEFAULT_TTL;
+ IPHeaderOUT->SourceAddress = ServerIPAddress;
+ IPHeaderOUT->DestinationAddress = ConnectionStateTable[CSTableEntry].RemoteAddress;
+
+ IPHeaderOUT->HeaderChecksum = Ethernet_Checksum16(IPHeaderOUT, sizeof(IP_Header_t));
+
+ PacketSize += sizeof(IP_Header_t);
+
+ /* Fill out the response Ethernet frame header */
+ FrameOUTHeader->Source = ServerMACAddress;
+ FrameOUTHeader->Destination = (MAC_Address_t){{0x02, 0x00, 0x02, 0x00, 0x02, 0x00}};
+ FrameOUTHeader->EtherType = SwapEndian_16(ETHERTYPE_IPV4);
+
+ PacketSize += sizeof(Ethernet_Frame_Header_t);
+
+ /* Set the response length in the buffer and indicate that a response is ready to be sent */
+ FrameOUT.FrameLength = PacketSize;
+
+ ConnectionStateTable[CSTableEntry].Info.Buffer.Ready = false;
+
+ break;
+ }
+ }
+}
+
+/** Initializes the TCP protocol handler, clearing the port and connection state tables. This must be called before TCP packets are
+ * processed.
+ */
+void TCP_Init(void)
+{
+ /* Initialize the port state table with all CLOSED entries */
+ for (uint8_t PTableEntry = 0; PTableEntry < MAX_OPEN_TCP_PORTS; PTableEntry++)
+ PortStateTable[PTableEntry].State = TCP_Port_Closed;
+
+ /* Initialize the connection table with all CLOSED entries */
+ for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
+ ConnectionStateTable[CSTableEntry].State = TCP_Connection_Closed;
+}
+
+/** Sets the state and callback handler of the given port, specified in big endian to the given state.
+ *
+ * \param[in] Port Port whose state and callback function to set, specified in big endian
+ * \param[in] State New state of the port, a value from the \ref TCP_PortStates_t enum
+ * \param[in] Handler Application callback handler for the port
+ *
+ * \return Boolean \c true if the port state was set, \c false otherwise (no more space in the port state table)
+ */
+bool TCP_SetPortState(const uint16_t Port,
+ const uint8_t State,
+ void (*Handler)(TCP_ConnectionState_t*, TCP_ConnectionBuffer_t*))
+{
+ /* Note, Port number should be specified in BIG endian to simplify network code */
+
+ /* Check to see if the port entry is already in the port state table */
+ for (uint8_t PTableEntry = 0; PTableEntry < MAX_OPEN_TCP_PORTS; PTableEntry++)
+ {
+ /* Find existing entry for the port in the table, update it if found */
+ if (PortStateTable[PTableEntry].Port == Port)
+ {
+ PortStateTable[PTableEntry].State = State;
+ PortStateTable[PTableEntry].ApplicationHandler = Handler;
+ return true;
+ }
+ }
+
+ /* Check if trying to open the port -- if so we need to find an unused (closed) entry and replace it */
+ if (State == TCP_Port_Open)
+ {
+ for (uint8_t PTableEntry = 0; PTableEntry < MAX_OPEN_TCP_PORTS; PTableEntry++)
+ {
+ /* Find a closed port entry in the table, change it to the given port and state */
+ if (PortStateTable[PTableEntry].State == TCP_Port_Closed)
+ {
+ PortStateTable[PTableEntry].Port = Port;
+ PortStateTable[PTableEntry].State = State;
+ PortStateTable[PTableEntry].ApplicationHandler = Handler;
+ return true;
+ }
+ }
+
+ /* Port not in table and no room to add it, return failure */
+ return false;
+ }
+ else
+ {
+ /* Port not in table but trying to close it, so operation successful */
+ return true;
+ }
+}
+
+/** Retrieves the current state of a given TCP port, specified in big endian.
+ *
+ * \param[in] Port TCP port whose state is to be retrieved, given in big-endian
+ *
+ * \return A value from the \ref TCP_PortStates_t enum
+ */
+uint8_t TCP_GetPortState(const uint16_t Port)
+{
+ /* Note, Port number should be specified in BIG endian to simplify network code */
+
+ for (uint8_t PTableEntry = 0; PTableEntry < MAX_OPEN_TCP_PORTS; PTableEntry++)
+ {
+ /* Find existing entry for the port in the table, return the port status if found */
+ if (PortStateTable[PTableEntry].Port == Port)
+ return PortStateTable[PTableEntry].State;
+ }
+
+ /* Port not in table, assume closed */
+ return TCP_Port_Closed;
+}
+
+/** Sets the connection state of the given port, remote address and remote port to the given TCP connection state. If the
+ * connection exists in the connection state table it is updated, otherwise it is created if possible.
+ *
+ * \param[in] Port TCP port of the connection on the device, specified in big endian
+ * \param[in] RemoteAddress Remote protocol IP address of the connected device
+ * \param[in] RemotePort TCP port of the remote device in the connection, specified in big endian
+ * \param[in] State TCP connection state, a value from the \ref TCP_ConnectionStates_t enum
+ *
+ * \return Boolean \c true if the connection was updated or created, \c false otherwise (no more space in the connection state table)
+ */
+bool TCP_SetConnectionState(const uint16_t Port,
+ const IP_Address_t* RemoteAddress,
+ const uint16_t RemotePort,
+ const uint8_t State)
+{
+ /* Note, Port number should be specified in BIG endian to simplify network code */
+
+ for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
+ {
+ /* Find port entry in the table */
+ if ((ConnectionStateTable[CSTableEntry].Port == Port) &&
+ IP_COMPARE(&ConnectionStateTable[CSTableEntry].RemoteAddress, RemoteAddress) &&
+ ConnectionStateTable[CSTableEntry].RemotePort == RemotePort)
+ {
+ ConnectionStateTable[CSTableEntry].State = State;
+ return true;
+ }
+ }
+
+ for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
+ {
+ /* Find empty entry in the table */
+ if (ConnectionStateTable[CSTableEntry].State == TCP_Connection_Closed)
+ {
+ ConnectionStateTable[CSTableEntry].Port = Port;
+ ConnectionStateTable[CSTableEntry].RemoteAddress = *RemoteAddress;
+ ConnectionStateTable[CSTableEntry].RemotePort = RemotePort;
+ ConnectionStateTable[CSTableEntry].State = State;
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/** Retrieves the current state of a given TCP connection to a host.
+ *
+ * \param[in] Port TCP port on the device in the connection, specified in big endian
+ * \param[in] RemoteAddress Remote protocol IP address of the connected host
+ * \param[in] RemotePort Remote TCP port of the connected host, specified in big endian
+ *
+ * \return A value from the \ref TCP_ConnectionStates_t enum
+ */
+uint8_t TCP_GetConnectionState(const uint16_t Port,
+ const IP_Address_t* RemoteAddress,
+ const uint16_t RemotePort)
+{
+ /* Note, Port number should be specified in BIG endian to simplify network code */
+
+ for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
+ {
+ /* Find port entry in the table */
+ if ((ConnectionStateTable[CSTableEntry].Port == Port) &&
+ IP_COMPARE(&ConnectionStateTable[CSTableEntry].RemoteAddress, RemoteAddress) &&
+ ConnectionStateTable[CSTableEntry].RemotePort == RemotePort)
+
+ {
+ return ConnectionStateTable[CSTableEntry].State;
+ }
+ }
+
+ return TCP_Connection_Closed;
+}
+
+/** Retrieves the connection info structure of a given connection to a host.
+ *
+ * \param[in] Port TCP port on the device in the connection, specified in big endian
+ * \param[in] RemoteAddress Remote protocol IP address of the connected host
+ * \param[in] RemotePort Remote TCP port of the connected host, specified in big endian
+ *
+ * \return ConnectionInfo structure of the connection if found, NULL otherwise
+ */
+TCP_ConnectionInfo_t* TCP_GetConnectionInfo(const uint16_t Port,
+ const IP_Address_t* RemoteAddress,
+ const uint16_t RemotePort)
+{
+ /* Note, Port number should be specified in BIG endian to simplify network code */
+
+ for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
+ {
+ /* Find port entry in the table */
+ if ((ConnectionStateTable[CSTableEntry].Port == Port) &&
+ IP_COMPARE(&ConnectionStateTable[CSTableEntry].RemoteAddress, RemoteAddress) &&
+ ConnectionStateTable[CSTableEntry].RemotePort == RemotePort)
+ {
+ return &ConnectionStateTable[CSTableEntry].Info;
+ }
+ }
+
+ return NULL;
+}
+
+/** Processes a TCP packet inside an Ethernet frame, and writes the appropriate response
+ * to the output Ethernet frame if one is created by a application handler.
+ *
+ * \param[in] IPHeaderInStart Pointer to the start of the incoming packet's IP header
+ * \param[in] TCPHeaderInStart Pointer to the start of the incoming packet's TCP header
+ * \param[out] TCPHeaderOutStart Pointer to the start of the outgoing packet's TCP header
+ *
+ * \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no
+ * response was generated, NO_PROCESS if the packet processing was deferred until the
+ * next Ethernet packet handler iteration
+ */
+int16_t TCP_ProcessTCPPacket(void* IPHeaderInStart,
+ void* TCPHeaderInStart,
+ void* TCPHeaderOutStart)
+{
+ IP_Header_t* IPHeaderIN = (IP_Header_t*)IPHeaderInStart;
+ TCP_Header_t* TCPHeaderIN = (TCP_Header_t*)TCPHeaderInStart;
+ TCP_Header_t* TCPHeaderOUT = (TCP_Header_t*)TCPHeaderOutStart;
+
+ TCP_ConnectionInfo_t* ConnectionInfo;
+
+ DecodeTCPHeader(TCPHeaderInStart);
+
+ bool PacketResponse = false;
+
+ /* Check if the destination port is open and allows incoming connections */
+ if (TCP_GetPortState(TCPHeaderIN->DestinationPort) == TCP_Port_Open)
+ {
+ /* Detect SYN from host to start a connection */
+ if (TCPHeaderIN->Flags & TCP_FLAG_SYN)
+ TCP_SetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress, TCPHeaderIN->SourcePort, TCP_Connection_Listen);
+
+ /* Detect RST from host to abort existing connection */
+ if (TCPHeaderIN->Flags & TCP_FLAG_RST)
+ {
+ if (TCP_SetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort, TCP_Connection_Closed))
+ {
+ TCPHeaderOUT->Flags = (TCP_FLAG_RST | TCP_FLAG_ACK);
+ PacketResponse = true;
+ }
+ }
+ else
+ {
+ /* Process the incoming TCP packet based on the current connection state for the sender and port */
+ switch (TCP_GetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress, TCPHeaderIN->SourcePort))
+ {
+ case TCP_Connection_Listen:
+ if (TCPHeaderIN->Flags == TCP_FLAG_SYN)
+ {
+ /* SYN connection starts a connection with a peer */
+ if (TCP_SetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort, TCP_Connection_SYNReceived))
+ {
+ TCPHeaderOUT->Flags = (TCP_FLAG_SYN | TCP_FLAG_ACK);
+
+ ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress, TCPHeaderIN->SourcePort);
+
+ ConnectionInfo->SequenceNumberIn = (SwapEndian_32(TCPHeaderIN->SequenceNumber) + 1);
+ ConnectionInfo->SequenceNumberOut = 0;
+ ConnectionInfo->Buffer.InUse = false;
+ }
+ else
+ {
+ TCPHeaderOUT->Flags = TCP_FLAG_RST;
+ }
+
+ PacketResponse = true;
+ }
+
+ break;
+ case TCP_Connection_SYNReceived:
+ if (TCPHeaderIN->Flags == TCP_FLAG_ACK)
+ {
+ /* ACK during the connection process completes the connection to a peer */
+
+ TCP_SetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort, TCP_Connection_Established);
+
+ ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort);
+
+ ConnectionInfo->SequenceNumberOut++;
+ }
+
+ break;
+ case TCP_Connection_Established:
+ if (TCPHeaderIN->Flags == (TCP_FLAG_FIN | TCP_FLAG_ACK))
+ {
+ /* FIN ACK when connected to a peer starts the finalization process */
+
+ TCPHeaderOUT->Flags = (TCP_FLAG_FIN | TCP_FLAG_ACK);
+ PacketResponse = true;
+
+ TCP_SetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort, TCP_Connection_CloseWait);
+
+ ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort);
+
+ ConnectionInfo->SequenceNumberIn++;
+ ConnectionInfo->SequenceNumberOut++;
+ }
+ else if ((TCPHeaderIN->Flags == TCP_FLAG_ACK) || (TCPHeaderIN->Flags == (TCP_FLAG_ACK | TCP_FLAG_PSH)))
+ {
+ ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort);
+
+ /* Check if the buffer is currently in use either by a buffered data to send, or receive */
+ if ((ConnectionInfo->Buffer.InUse == false) && (ConnectionInfo->Buffer.Ready == false))
+ {
+ ConnectionInfo->Buffer.Direction = TCP_PACKETDIR_IN;
+ ConnectionInfo->Buffer.InUse = true;
+ ConnectionInfo->Buffer.Length = 0;
+ }
+
+ /* Check if the buffer has been claimed by us to read in data from the peer */
+ if ((ConnectionInfo->Buffer.Direction == TCP_PACKETDIR_IN) &&
+ (ConnectionInfo->Buffer.Length != TCP_WINDOW_SIZE))
+ {
+ uint16_t IPOffset = (IPHeaderIN->HeaderLength * sizeof(uint32_t));
+ uint16_t TCPOffset = (TCPHeaderIN->DataOffset * sizeof(uint32_t));
+ uint16_t DataLength = (SwapEndian_16(IPHeaderIN->TotalLength) - IPOffset - TCPOffset);
+
+ /* Copy the packet data into the buffer */
+ memcpy(&ConnectionInfo->Buffer.Data[ConnectionInfo->Buffer.Length],
+ &((uint8_t*)TCPHeaderInStart)[TCPOffset],
+ DataLength);
+
+ ConnectionInfo->SequenceNumberIn += DataLength;
+ ConnectionInfo->Buffer.Length += DataLength;
+
+ /* Check if the buffer is full or if the PSH flag is set, if so indicate buffer ready */
+ if ((!(TCP_WINDOW_SIZE - ConnectionInfo->Buffer.Length)) || (TCPHeaderIN->Flags & TCP_FLAG_PSH))
+ {
+ ConnectionInfo->Buffer.InUse = false;
+ ConnectionInfo->Buffer.Ready = true;
+
+ TCPHeaderOUT->Flags = TCP_FLAG_ACK;
+ PacketResponse = true;
+ }
+ }
+ else
+ {
+ /* Buffer is currently in use by the application, defer processing of the incoming packet */
+ return NO_PROCESS;
+ }
+ }
+
+ break;
+ case TCP_Connection_Closing:
+ ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort);
+
+ TCPHeaderOUT->Flags = (TCP_FLAG_ACK | TCP_FLAG_FIN);
+ PacketResponse = true;
+
+ ConnectionInfo->Buffer.InUse = false;
+
+ TCP_SetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort, TCP_Connection_FINWait1);
+
+ break;
+ case TCP_Connection_FINWait1:
+ if (TCPHeaderIN->Flags == (TCP_FLAG_FIN | TCP_FLAG_ACK))
+ {
+ ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort);
+
+ TCPHeaderOUT->Flags = TCP_FLAG_ACK;
+ PacketResponse = true;
+
+ ConnectionInfo->SequenceNumberIn++;
+ ConnectionInfo->SequenceNumberOut++;
+
+ TCP_SetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort, TCP_Connection_Closed);
+ }
+ else if (TCPHeaderIN->Flags == TCP_FLAG_ACK)
+ {
+ TCP_SetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort, TCP_Connection_FINWait2);
+ }
+
+ break;
+ case TCP_Connection_FINWait2:
+ if (TCPHeaderIN->Flags == (TCP_FLAG_FIN | TCP_FLAG_ACK))
+ {
+ ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort);
+
+ TCPHeaderOUT->Flags = TCP_FLAG_ACK;
+ PacketResponse = true;
+
+ ConnectionInfo->SequenceNumberIn++;
+ ConnectionInfo->SequenceNumberOut++;
+
+ TCP_SetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort, TCP_Connection_Closed);
+ }
+
+ break;
+ case TCP_Connection_CloseWait:
+ if (TCPHeaderIN->Flags == TCP_FLAG_ACK)
+ {
+ TCP_SetConnectionState(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort, TCP_Connection_Closed);
+ }
+
+ break;
+ }
+ }
+ }
+ else
+ {
+ /* Port is not open, indicate via a RST/ACK response to the sender */
+ TCPHeaderOUT->Flags = (TCP_FLAG_RST | TCP_FLAG_ACK);
+ PacketResponse = true;
+ }
+
+ /* Check if we need to respond to the sent packet */
+ if (PacketResponse)
+ {
+ ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, &IPHeaderIN->SourceAddress,
+ TCPHeaderIN->SourcePort);
+
+ TCPHeaderOUT->SourcePort = TCPHeaderIN->DestinationPort;
+ TCPHeaderOUT->DestinationPort = TCPHeaderIN->SourcePort;
+ TCPHeaderOUT->SequenceNumber = SwapEndian_32(ConnectionInfo->SequenceNumberOut);
+ TCPHeaderOUT->AcknowledgmentNumber = SwapEndian_32(ConnectionInfo->SequenceNumberIn);
+ TCPHeaderOUT->DataOffset = (sizeof(TCP_Header_t) / sizeof(uint32_t));
+
+ if (!(ConnectionInfo->Buffer.InUse))
+ TCPHeaderOUT->WindowSize = SwapEndian_16(TCP_WINDOW_SIZE);
+ else
+ TCPHeaderOUT->WindowSize = SwapEndian_16(TCP_WINDOW_SIZE - ConnectionInfo->Buffer.Length);
+
+ TCPHeaderOUT->UrgentPointer = 0;
+ TCPHeaderOUT->Checksum = 0;
+ TCPHeaderOUT->Reserved = 0;
+
+ TCPHeaderOUT->Checksum = TCP_Checksum16(TCPHeaderOUT, &IPHeaderIN->DestinationAddress,
+ &IPHeaderIN->SourceAddress, sizeof(TCP_Header_t));
+
+ return sizeof(TCP_Header_t);
+ }
+
+ return NO_RESPONSE;
+}
+
+/** Calculates the appropriate TCP checksum, consisting of the addition of the one's compliment of each word,
+ * complimented.
+ *
+ * \param[in] TCPHeaderOutStart Pointer to the start of the packet's outgoing TCP header
+ * \param[in] SourceAddress Source protocol IP address of the outgoing IP header
+ * \param[in] DestinationAddress Destination protocol IP address of the outgoing IP header
+ * \param[in] TCPOutSize Size in bytes of the TCP data header and payload
+ *
+ * \return A 16-bit TCP checksum value
+ */
+static uint16_t TCP_Checksum16(void* TCPHeaderOutStart,
+ const IP_Address_t* SourceAddress,
+ const IP_Address_t* DestinationAddress,
+ uint16_t TCPOutSize)
+{
+ uint32_t Checksum = 0;
+
+ /* TCP/IP checksums are the addition of the one's compliment of each word including the IP pseudo-header,
+ complimented */
+
+ Checksum += ((uint16_t*)SourceAddress)[0];
+ Checksum += ((uint16_t*)SourceAddress)[1];
+ Checksum += ((uint16_t*)DestinationAddress)[0];
+ Checksum += ((uint16_t*)DestinationAddress)[1];
+ Checksum += SwapEndian_16(PROTOCOL_TCP);
+ Checksum += SwapEndian_16(TCPOutSize);
+
+ for (uint16_t CurrWord = 0; CurrWord < (TCPOutSize >> 1); CurrWord++)
+ Checksum += ((uint16_t*)TCPHeaderOutStart)[CurrWord];
+
+ if (TCPOutSize & 0x01)
+ Checksum += (((uint16_t*)TCPHeaderOutStart)[TCPOutSize >> 1] & 0x00FF);
+
+ while (Checksum & 0xFFFF0000)
+ Checksum = ((Checksum & 0xFFFF) + (Checksum >> 16));
+
+ return ~Checksum;
+}
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.h
new file mode 100644
index 0000000000..ce8a9a2d0f
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.h
@@ -0,0 +1,260 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 TCP.c.
+ */
+
+#ifndef _TCP_H_
+#define _TCP_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+ #include <stdbool.h>
+
+ #include "EthernetProtocols.h"
+ #include "Ethernet.h"
+ #include "ProtocolDecoders.h"
+
+ /* Macros: */
+ /** Maximum number of TCP ports which can be open at the one time. */
+ #define MAX_OPEN_TCP_PORTS 1
+
+ /** Maximum number of TCP connections which can be sustained at the one time. */
+ #define MAX_TCP_CONNECTIONS 3
+
+ /** TCP window size, giving the maximum number of bytes which can be buffered at the one time. */
+ #define TCP_WINDOW_SIZE 512
+
+ /** Port number for HTTP transmissions. */
+ #define TCP_PORT_HTTP SwapEndian_16(80)
+
+ /** Data direction indicator for a TCP application buffer, indicating data from host-to-device. */
+ #define TCP_PACKETDIR_IN false
+
+ /** Data direction indicator for a TCP application buffer, indicating data from device-to-host. */
+ #define TCP_PACKETDIR_OUT true
+
+ /** Congestion Window Reduced TCP flag mask. */
+ #define TCP_FLAG_CWR (1 << 7)
+
+ /** Explicit Congestion Notification TCP flag mask. */
+ #define TCP_FLAG_ECE (1 << 6)
+
+ /** Urgent TCP flag mask. */
+ #define TCP_FLAG_URG (1 << 5)
+
+ /** Data Acknowledge TCP flag mask. */
+ #define TCP_FLAG_ACK (1 << 4)
+
+ /** Data Push TCP flag mask. */
+ #define TCP_FLAG_PSH (1 << 3)
+
+ /** Reset TCP flag mask. */
+ #define TCP_FLAG_RST (1 << 2)
+
+ /** Synchronize TCP flag mask. */
+ #define TCP_FLAG_SYN (1 << 1)
+
+ /** Connection Finalize TCP flag mask. */
+ #define TCP_FLAG_FIN (1 << 0)
+
+ /** Application macro: Determines if the given application buffer contains a packet received from the host
+ *
+ * \param[in] Buffer Application buffer to check
+ *
+ * \return Boolean \c true if the buffer contains a packet from the host, \c false otherwise
+ */
+ #define TCP_APP_HAS_RECEIVED_PACKET(Buffer) (Buffer->Ready && (Buffer->Direction == TCP_PACKETDIR_IN))
+
+ /** Application macro: Indicates if the application buffer is currently locked by the application for device-to-host transfers.
+ *
+ * \param[in] Buffer Application buffer to check
+ *
+ * \return Boolean \c true if the buffer has been captured by the application for device-to-host transmissions, \c false otherwise
+ */
+ #define TCP_APP_HAVE_CAPTURED_BUFFER(Buffer) (!(Buffer->Ready) && Buffer->InUse && \
+ (Buffer->Direction == TCP_PACKETDIR_OUT))
+
+ /** Application macro: Indicates if the application can lock the buffer for multiple continued device-to-host transmissions.
+ *
+ * \param[in] Buffer Application buffer to check
+ *
+ * \return Boolean \c true if the buffer may be captured by the application for device-to-host transmissions, \c false otherwise
+ */
+ #define TCP_APP_CAN_CAPTURE_BUFFER(Buffer) Buffer->InUse
+
+ /** Application macro: Captures the application buffer, locking it for device-to-host transmissions only. This should be
+ * performed when the application needs to transmit several packets worth of data in succession with no interruptions from the host.
+ *
+ * \pre The application must check that the buffer can be locked first using TCP_APP_CAN_CAPTURE_BUFFER().
+ *
+ * \param[in] Buffer Application buffer to lock
+ */
+ #define TCP_APP_CAPTURE_BUFFER(Buffer) do { Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->InUse = true; } while (0)
+
+ /** Application macro: Releases a captured application buffer, allowing for host-to-device packets to be received.
+ *
+ * \param[in] Buffer Application buffer to release
+ */
+ #define TCP_APP_RELEASE_BUFFER(Buffer) do { Buffer->InUse = false; } while (0)
+
+ /** Application macro: Sends the contents of the given application buffer to the host.
+ *
+ * \param[in] Buffer Application buffer to send
+ * \param[in] Len Length of data contained in the buffer
+ */
+ #define TCP_APP_SEND_BUFFER(Buffer, Len) do { Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->Length = Len; Buffer->Ready = true; } while (0)
+
+ /** Application macro: Clears the application buffer, ready for a packet to be written to it.
+ *
+ * \param[in] Buffer Application buffer to clear
+ */
+ #define TCP_APP_CLEAR_BUFFER(Buffer) do { Buffer->Ready = false; Buffer->Length = 0; } while (0)
+
+ /** Application macro: Closes an open connection to a host.
+ *
+ * \param[in] Connection Open TCP connection to close
+ */
+ #define TCP_APP_CLOSECONNECTION(Connection) do { Connection->State = TCP_Connection_Closing; } while (0)
+
+ /* Enums: */
+ /** Enum for possible TCP port states. */
+ enum TCP_PortStates_t
+ {
+ TCP_Port_Closed = 0, /**< TCP port closed, no connections to a host may be made on this port. */
+ TCP_Port_Open = 1, /**< TCP port open, connections to a host may be made on this port. */
+ };
+
+ /** Enum for possible TCP connection states. */
+ enum TCP_ConnectionStates_t
+ {
+ TCP_Connection_Listen = 0, /**< Listening for a connection from a host */
+ TCP_Connection_SYNSent = 1, /**< Unused */
+ TCP_Connection_SYNReceived = 2, /**< SYN received, waiting for ACK */
+ TCP_Connection_Established = 3, /**< Connection established in both directions */
+ TCP_Connection_FINWait1 = 4, /**< Closing, waiting for ACK */
+ TCP_Connection_FINWait2 = 5, /**< Closing, waiting for FIN ACK */
+ TCP_Connection_CloseWait = 6, /**< Closing, waiting for ACK */
+ TCP_Connection_Closing = 7, /**< Unused */
+ TCP_Connection_LastACK = 8, /**< Unused */
+ TCP_Connection_TimeWait = 9, /**< Unused */
+ TCP_Connection_Closed = 10, /**< Connection closed in both directions */
+ };
+
+ /* Type Defines: */
+ /** Type define for a TCP connection buffer structure, including size, data and direction. */
+ typedef struct
+ {
+ uint16_t Length; /**< Length of data in the TCP application buffer */
+ uint8_t Data[TCP_WINDOW_SIZE]; /**< TCP application data buffer */
+ bool Direction; /**< Buffer transmission direction, either TCP_PACKETDIR_IN or TCP_PACKETDIR_OUT */
+ bool Ready; /**< If data from host, indicates buffer ready to be read, otherwise indicates
+ * buffer ready to be sent to the host
+ */
+ bool InUse; /**< Indicates if the buffer is locked to to the current direction, and cannot be changed */
+ } TCP_ConnectionBuffer_t;
+
+ /** Type define for a TCP connection information structure. */
+ typedef struct
+ {
+ uint32_t SequenceNumberIn; /**< Current TCP sequence number for host-to-device */
+ uint32_t SequenceNumberOut; /**< Current TCP sequence number for device-to-host */
+ TCP_ConnectionBuffer_t Buffer; /**< Connection application data buffer */
+ } TCP_ConnectionInfo_t;
+
+ /** Type define for a complete TCP connection state. */
+ typedef struct
+ {
+ uint16_t Port; /**< Connection port number on the device */
+ uint16_t RemotePort; /**< Connection port number on the host */
+ IP_Address_t RemoteAddress; /**< Connection protocol IP address of the host */
+ TCP_ConnectionInfo_t Info; /**< Connection information, including application buffer */
+ uint8_t State; /**< Current connection state, a value from the \ref TCP_ConnectionStates_t enum */
+ } TCP_ConnectionState_t;
+
+ /** Type define for a TCP port state. */
+ typedef struct
+ {
+ uint16_t Port; /**< TCP port number on the device */
+ uint8_t State; /**< Current port state, a value from the \ref TCP_PortStates_t enum */
+ void (*ApplicationHandler) (TCP_ConnectionState_t* ConnectionState,
+ TCP_ConnectionBuffer_t* Buffer); /**< Port application handler */
+ } TCP_PortState_t;
+
+ /** Type define for a TCP packet header. */
+ typedef struct
+ {
+ uint16_t SourcePort; /**< Source port of the TCP packet */
+ uint16_t DestinationPort; /**< Destination port of the TCP packet */
+
+ uint32_t SequenceNumber; /**< Data sequence number of the packet */
+ uint32_t AcknowledgmentNumber; /**< Data acknowledgment number of the packet */
+
+ unsigned Reserved : 4; /**< Reserved, must be all 0 */
+ unsigned DataOffset : 4; /**< Offset of the data from the start of the header, in 4 byte chunks */
+ uint8_t Flags; /**< TCP packet flags */
+ uint16_t WindowSize; /**< Current data window size (bytes remaining in reception buffer) */
+
+ uint16_t Checksum; /**< TCP checksum */
+ uint16_t UrgentPointer; /**< Urgent data pointer */
+ } TCP_Header_t;
+
+ /* Function Prototypes: */
+ void TCP_Init(void);
+ void TCP_Task(void);
+ bool TCP_SetPortState(const uint16_t Port,
+ const uint8_t State,
+ void (*Handler)(TCP_ConnectionState_t*, TCP_ConnectionBuffer_t*));
+ uint8_t TCP_GetPortState(const uint16_t Port);
+ bool TCP_SetConnectionState(const uint16_t Port,
+ const IP_Address_t* RemoteAddress,
+ const uint16_t RemotePort,
+ const uint8_t State);
+ uint8_t TCP_GetConnectionState(const uint16_t Port,
+ const IP_Address_t* RemoteAddress,
+ const uint16_t RemotePort);
+ TCP_ConnectionInfo_t* TCP_GetConnectionInfo(const uint16_t Port,
+ const IP_Address_t* RemoteAddress,
+ const uint16_t RemotePort);
+ int16_t TCP_ProcessTCPPacket(void* IPHeaderInStart,
+ void* TCPHeaderInStart,
+ void* TCPHeaderOutStart);
+
+ #if defined(INCLUDE_FROM_TCP_C)
+ static uint16_t TCP_Checksum16(void* TCPHeaderOutStart,
+ const IP_Address_t* SourceAddress,
+ const IP_Address_t* DestinationAddress,
+ uint16_t TCPOutSize);
+ #endif
+
+#endif
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.c b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.c
new file mode 100644
index 0000000000..03c19e00ed
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.c
@@ -0,0 +1,84 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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
+ *
+ * User Datagram Protocol (UDP) packet handling routines. This protocol handles high throughput, low
+ * reliability packets which are typically used to encapsulate streaming data.
+ */
+
+#define INCLUDE_FROM_UDP_C
+#include "UDP.h"
+
+/** Processes a UDP packet inside an Ethernet frame, and writes the appropriate response
+ * to the output Ethernet frame if a sub-protocol handler has created a response packet.
+ *
+ * \param[in] IPHeaderInStart Pointer to the start of the incoming packet's IP header
+ * \param[in] UDPHeaderInStart Pointer to the start of the incoming packet's UDP header
+ * \param[out] UDPHeaderOutStart Pointer to the start of the outgoing packet's UDP header
+ *
+ * \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
+ */
+int16_t UDP_ProcessUDPPacket(void* IPHeaderInStart,
+ void* UDPHeaderInStart,
+ void* UDPHeaderOutStart)
+{
+ UDP_Header_t* UDPHeaderIN = (UDP_Header_t*)UDPHeaderInStart;
+ UDP_Header_t* UDPHeaderOUT = (UDP_Header_t*)UDPHeaderOutStart;
+
+ int16_t RetSize = NO_RESPONSE;
+
+ DecodeUDPHeader(UDPHeaderInStart);
+
+ switch (SwapEndian_16(UDPHeaderIN->DestinationPort))
+ {
+ case UDP_PORT_DHCP_REQUEST:
+ RetSize = DHCP_ProcessDHCPPacket(IPHeaderInStart,
+ &((uint8_t*)UDPHeaderInStart)[sizeof(UDP_Header_t)],
+ &((uint8_t*)UDPHeaderOutStart)[sizeof(UDP_Header_t)]);
+ break;
+ }
+
+ /* Check to see if the protocol processing routine has filled out a response */
+ if (RetSize > 0)
+ {
+ /* Fill out the response UDP packet header */
+ UDPHeaderOUT->SourcePort = UDPHeaderIN->DestinationPort;
+ UDPHeaderOUT->DestinationPort = UDPHeaderIN->SourcePort;
+ UDPHeaderOUT->Checksum = 0;
+ UDPHeaderOUT->Length = SwapEndian_16(sizeof(UDP_Header_t) + RetSize);
+
+ /* Return the size of the response so far */
+ return (sizeof(UDP_Header_t) + RetSize);
+ }
+
+ return NO_RESPONSE;
+}
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.h
new file mode 100644
index 0000000000..d008cb8ed8
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.h
@@ -0,0 +1,73 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 UDP.c.
+ */
+
+#ifndef _UDP_H_
+#define _UDP_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+
+ #include "EthernetProtocols.h"
+ #include "Ethernet.h"
+ #include "ProtocolDecoders.h"
+ #include "DHCP.h"
+
+ /* Macros: */
+ /** Source UDP port for a DHCP request. */
+ #define UDP_PORT_DHCP_REQUEST 67
+
+ /** Destination UDP port for a DHCP reply. */
+ #define UDP_PORT_DHCP_REPLY 68
+
+ /** Source UDP port for a DNS request/response. */
+ #define UDP_PORT_DNS 53
+
+ /* Type Defines: */
+ /** Type define for a UDP packet header. */
+ typedef struct
+ {
+ uint16_t SourcePort; /**< Packet source port */
+ uint16_t DestinationPort; /**< Packet destination port */
+ uint16_t Length; /**< Total packet length, in bytes */
+ uint16_t Checksum; /**< Optional UDP packet checksum */
+ } UDP_Header_t;
+
+ /* Function Prototypes: */
+ int16_t UDP_ProcessUDPPacket(void* IPHeaderInStart,
+ void* UDPHeaderInStart,
+ void* UDPHeaderOutStart);
+
+#endif
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.c b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.c
new file mode 100644
index 0000000000..e0d9e36473
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.c
@@ -0,0 +1,203 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 webserver application for demonstrating the RNDIS demo and TCP/IP stack. This
+ * application will serve up a static HTTP webpage when requested by the host.
+ */
+
+#include "Webserver.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 RNDIS\r\n"
+ "Content-type: text/html\r\n"
+ "Connection: close\r\n\r\n";
+
+/** 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 RNDIS\r\n"
+ "Connection: close\r\n\r\n";
+
+/** HTTP page to serve to the host when a HTTP request is made. This page is too long for a single response, thus it is automatically
+ * broken up into smaller blocks and sent as a series of packets each time the webserver application callback is run.
+ */
+const char PROGMEM HTTPPage[] =
+ "<html>"
+ " <head>"
+ " <title>"
+ " LUFA Webserver Demo"
+ " </title>"
+ " </head>"
+ " <body>"
+ " <h1>Hello from your USB AVR!</h1>"
+ " <p>"
+ " Hello! Welcome to the LUFA RNDIS Demo Webserver test page, running on your USB AVR via the LUFA library. This demonstrates the HTTP webserver, TCP/IP stack and RNDIS demo all running atop the LUFA USB stack."
+ " <br /><br />"
+ " <small>Project Information: <a href=\"http://www.lufa-lib.org\">http://www.lufa-lib.org</a>.</small>"
+ " <hr />"
+ " <i>LUFA Version: </i>" LUFA_VERSION_STRING
+ " </p>"
+ " </body>"
+ "</html>";
+
+
+/** Initializes the Webserver application, opening the appropriate HTTP port in the TCP handler and registering the application
+ * callback routine for packets sent to the HTTP protocol port.
+ */
+void Webserver_Init(void)
+{
+ /* Open the HTTP port in the TCP protocol so that HTTP connections to the device can be established */
+ TCP_SetPortState(TCP_PORT_HTTP, TCP_Port_Open, Webserver_ApplicationCallback);
+}
+
+/** Indicates if a given request equals the given HTTP command.
+ *
+ * \param[in] RequestHeader HTTP request made by the host
+ * \param[in] Command HTTP command to compare the request to
+ *
+ * \return Boolean \c true if the command matches the request, \c false otherwise
+ */
+static bool IsHTTPCommand(uint8_t* RequestHeader,
+ char* Command)
+{
+ /* Returns true if the non null terminated string in RequestHeader matches the null terminated string Command */
+ return (strncmp((char*)RequestHeader, Command, strlen(Command)) == 0);
+}
+
+/** Application callback routine, executed each time the TCP processing task runs. This callback determines what request
+ * has been made (if any), and serves up appropriate responses.
+ *
+ * \param[in] ConnectionState Pointer to a TCP Connection State structure giving connection information
+ * \param[in,out] Buffer Pointer to the application's send/receive packet buffer
+ */
+void Webserver_ApplicationCallback(TCP_ConnectionState_t* const ConnectionState,
+ TCP_ConnectionBuffer_t* const Buffer)
+{
+ char* BufferDataStr = (char*)Buffer->Data;
+ static uint8_t PageBlock = 0;
+
+ /* Check to see if a packet has been received on the HTTP port from a remote host */
+ if (TCP_APP_HAS_RECEIVED_PACKET(Buffer))
+ {
+ if (IsHTTPCommand(Buffer->Data, "GET"))
+ {
+ if (IsHTTPCommand(Buffer->Data, "GET / "))
+ {
+ PageBlock = 0;
+
+ /* Copy the HTTP 200 response header into the packet buffer */
+ strcpy_P(BufferDataStr, HTTP200Header);
+
+ /* Send the buffer contents to the host */
+ TCP_APP_SEND_BUFFER(Buffer, strlen(BufferDataStr));
+
+ /* Lock the buffer to Device->Host transmissions only while we send the page contents */
+ TCP_APP_CAPTURE_BUFFER(Buffer);
+ }
+ else
+ {
+ /* Copy the HTTP 404 response header into the packet buffer */
+ strcpy_P(BufferDataStr, HTTP404Header);
+
+ /* Send the buffer contents to the host */
+ TCP_APP_SEND_BUFFER(Buffer, strlen(BufferDataStr));
+
+ /* All data sent, close the connection */
+ TCP_APP_CLOSECONNECTION(ConnectionState);
+ }
+ }
+ else if (IsHTTPCommand(Buffer->Data, "HEAD"))
+ {
+ if (IsHTTPCommand(Buffer->Data, "HEAD / "))
+ {
+ /* Copy the HTTP response header into the packet buffer */
+ strcpy_P(BufferDataStr, HTTP200Header);
+
+ /* Send the buffer contents to the host */
+ TCP_APP_SEND_BUFFER(Buffer, strlen(BufferDataStr));
+ }
+ else
+ {
+ /* Copy the HTTP response header into the packet buffer */
+ strcpy_P(BufferDataStr, HTTP404Header);
+
+ /* Send the buffer contents to the host */
+ TCP_APP_SEND_BUFFER(Buffer, strlen(BufferDataStr));
+ }
+
+ /* All data sent, close the connection */
+ TCP_APP_CLOSECONNECTION(ConnectionState);
+ }
+ else if (IsHTTPCommand(Buffer->Data, "TRACE"))
+ {
+ /* Echo the host's query back to the host */
+ TCP_APP_SEND_BUFFER(Buffer, Buffer->Length);
+
+ /* All data sent, close the connection */
+ TCP_APP_CLOSECONNECTION(ConnectionState);
+ }
+ else
+ {
+ /* Unknown request, just clear the buffer (drop the packet) */
+ TCP_APP_CLEAR_BUFFER(Buffer);
+ }
+ }
+ else if (TCP_APP_HAVE_CAPTURED_BUFFER(Buffer))
+ {
+ uint16_t RemLength = strlen_P(&HTTPPage[PageBlock * HTTP_REPLY_BLOCK_SIZE]);
+ uint16_t Length;
+
+ /* Determine the length of the loaded block */
+ Length = MIN(RemLength, HTTP_REPLY_BLOCK_SIZE);
+
+ /* Copy the next buffer sized block of the page to the packet buffer */
+ strncpy_P(BufferDataStr, &HTTPPage[PageBlock * HTTP_REPLY_BLOCK_SIZE], Length);
+
+ /* Send the buffer contents to the host */
+ TCP_APP_SEND_BUFFER(Buffer, Length);
+
+ /* Check to see if the entire page has been sent */
+ if (PageBlock++ == (sizeof(HTTPPage) / HTTP_REPLY_BLOCK_SIZE))
+ {
+ /* Unlock the buffer so that the host can fill it with future packets */
+ TCP_APP_RELEASE_BUFFER(Buffer);
+
+ /* Close the connection to the host */
+ TCP_APP_CLOSECONNECTION(ConnectionState);
+ }
+ }
+}
+
diff --git a/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.h b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.h
new file mode 100644
index 0000000000..a73bd33384
--- /dev/null
+++ b/lib/lufa/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.h
@@ -0,0 +1,57 @@
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2017.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2017 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 disclaims 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 Webserver.c.
+ */
+
+#ifndef _WEBSERVER_H_
+#define _WEBSERVER_H_
+
+ /* Includes: */
+ #include <avr/io.h>
+ #include <avr/pgmspace.h>
+
+ #include <LUFA/Version.h>
+
+ #include "TCP.h"
+
+ /* Macros: */
+ /** Maximum size of a HTTP response per transmission */
+ #define HTTP_REPLY_BLOCK_SIZE 128
+
+ /* Function Prototypes: */
+ void Webserver_Init(void);
+ void Webserver_ApplicationCallback(TCP_ConnectionState_t* const ConnectionState,
+ TCP_ConnectionBuffer_t* const Buffer);
+
+#endif
+