tmk_core/protocol/lufa/LUFA-git/Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.h

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2014.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2014  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaims all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Header file for TCP.c.
  34  */
  35
  36 #ifndef _TCP_H_
  37 #define _TCP_H_
  38
  39         /* Includes: */
  40                 #include <avr/io.h>
  41                 #include <stdbool.h>
  42
  43                 #include "EthernetProtocols.h"
  44                 #include "Ethernet.h"
  45                 #include "ProtocolDecoders.h"
  46
  47         /* Macros: */
  48                 /** Maximum number of TCP ports which can be open at the one time. */
  49                 #define MAX_OPEN_TCP_PORTS              1
  50
  51                 /** Maximum number of TCP connections which can be sustained at the one time. */
  52                 #define MAX_TCP_CONNECTIONS             3
  53
  54                 /** TCP window size, giving the maximum number of bytes which can be buffered at the one time. */
  55                 #define TCP_WINDOW_SIZE                 512
  56
  57                 /** Port number for HTTP transmissions. */
  58                 #define TCP_PORT_HTTP                   SwapEndian_16(80)
  59
  60                 /** Data direction indicator for a TCP application buffer, indicating data from host-to-device. */
  61                 #define TCP_PACKETDIR_IN                false
  62
  63                 /** Data direction indicator for a TCP application buffer, indicating data from device-to-host. */
  64                 #define TCP_PACKETDIR_OUT               true
  65
  66                 /** Congestion Window Reduced TCP flag mask. */
  67                 #define TCP_FLAG_CWR                    (1 << 7)
  68
  69                 /** Explicit Congestion Notification TCP flag mask. */
  70                 #define TCP_FLAG_ECE                    (1 << 6)
  71
  72                 /** Urgent TCP flag mask. */
  73                 #define TCP_FLAG_URG                    (1 << 5)
  74
  75                 /** Data Acknowledge TCP flag mask. */
  76                 #define TCP_FLAG_ACK                    (1 << 4)
  77
  78                 /** Data Push TCP flag mask. */
  79                 #define TCP_FLAG_PSH                    (1 << 3)
  80
  81                 /** Reset TCP flag mask. */
  82                 #define TCP_FLAG_RST                    (1 << 2)
  83
  84                 /** Synchronize TCP flag mask. */
  85                 #define TCP_FLAG_SYN                    (1 << 1)
  86
  87                 /** Connection Finalize TCP flag mask. */
  88                 #define TCP_FLAG_FIN                    (1 << 0)
  89
  90                 /** Application macro: Determines if the given application buffer contains a packet received from the host
  91                  *
  92                  *  \param[in] Buffer  Application buffer to check
  93                  *
  94                  *  \return Boolean \c true if the buffer contains a packet from the host, \c false otherwise
  95                  */
  96                 #define TCP_APP_HAS_RECEIVED_PACKET(Buffer)  (Buffer->Ready && (Buffer->Direction == TCP_PACKETDIR_IN))
  97
  98                 /** Application macro: Indicates if the application buffer is currently locked by the application for device-to-host transfers.
  99                  *
 100                  *  \param[in] Buffer  Application buffer to check
 101                  *
 102                  *  \return Boolean \c true if the buffer has been captured by the application for device-to-host transmissions, \c false otherwise
 103                  */
 104                 #define TCP_APP_HAVE_CAPTURED_BUFFER(Buffer) (!(Buffer->Ready) && Buffer->InUse && (Buffer->Direction == TCP_PACKETDIR_OUT))
 105
 106                 /** Application macro: Indicates if the application can lock the buffer for multiple continued device-to-host transmissions.
 107                  *
 108                  *  \param[in] Buffer  Application buffer to check
 109                  *
 110                  *  \return Boolean \c true if the buffer may be captured by the application for device-to-host transmissions, \c false otherwise
 111                  */
 112                 #define TCP_APP_CAN_CAPTURE_BUFFER(Buffer)   Buffer->InUse
 113
 114                 /** Application macro: Captures the application buffer, locking it for device-to-host transmissions only. This should be
 115                  *  performed when the application needs to transmit several packets worth of data in succession with no interruptions from the host.
 116                  *
 117                  *  \pre The application must check that the buffer can be locked first using TCP_APP_CAN_CAPTURE_BUFFER().
 118                  *
 119                  *  \param[in] Buffer  Application buffer to lock
 120                  */
 121                 #define TCP_APP_CAPTURE_BUFFER(Buffer)       do { Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->InUse = true; } while (0)
 122
 123                 /** Application macro: Releases a captured application buffer, allowing for host-to-device packets to be received.
 124                  *
 125                  *  \param[in] Buffer  Application buffer to release
 126                  */
 127                 #define TCP_APP_RELEASE_BUFFER(Buffer)       do { Buffer->InUse = false; } while (0)
 128
 129                 /** Application macro: Sends the contents of the given application buffer to the host.
 130                  *
 131                  *  \param[in] Buffer  Application buffer to send
 132                  *  \param[in] Len     Length of data contained in the buffer
 133                  */
 134                 #define TCP_APP_SEND_BUFFER(Buffer, Len)     do { Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->Length = Len; Buffer->Ready = true; } while (0)
 135
 136                 /** Application macro: Clears the application buffer, ready for a packet to be written to it.
 137                  *
 138                  *  \param[in] Buffer  Application buffer to clear
 139                  */
 140                 #define TCP_APP_CLEAR_BUFFER(Buffer)         do { Buffer->Ready = false; Buffer->Length = 0; } while (0)
 141
 142                 /** Application macro: Closes an open connection to a host.
 143                  *
 144                  *  \param[in] Connection  Open TCP connection to close
 145                  */
 146                 #define TCP_APP_CLOSECONNECTION(Connection)  do { Connection->State = TCP_Connection_Closing;  } while (0)
 147
 148         /* Enums: */
 149                 /** Enum for possible TCP port states. */
 150                 enum TCP_PortStates_t
 151                 {
 152                         TCP_Port_Closed            = 0, /**< TCP port closed, no connections to a host may be made on this port. */
 153                         TCP_Port_Open              = 1, /**< TCP port open, connections to a host may be made on this port. */
 154                 };
 155
 156                 /** Enum for possible TCP connection states. */
 157                 enum TCP_ConnectionStates_t
 158                 {
 159                         TCP_Connection_Listen      = 0, /**< Listening for a connection from a host */
 160                         TCP_Connection_SYNSent     = 1, /**< Unused */
 161                         TCP_Connection_SYNReceived = 2, /**< SYN received, waiting for ACK */
 162                         TCP_Connection_Established = 3, /**< Connection established in both directions */
 163                         TCP_Connection_FINWait1    = 4, /**< Closing, waiting for ACK */
 164                         TCP_Connection_FINWait2    = 5, /**< Closing, waiting for FIN ACK */
 165                         TCP_Connection_CloseWait   = 6, /**< Closing, waiting for ACK */
 166                         TCP_Connection_Closing     = 7, /**< Unused */
 167                         TCP_Connection_LastACK     = 8, /**< Unused */
 168                         TCP_Connection_TimeWait    = 9, /**< Unused */
 169                         TCP_Connection_Closed      = 10, /**< Connection closed in both directions */
 170                 };
 171
 172         /* Type Defines: */
 173                 /** Type define for a TCP connection buffer structure, including size, data and direction. */
 174                 typedef struct
 175                 {
 176                         uint16_t               Length; /**< Length of data in the TCP application buffer */
 177                         uint8_t                Data[TCP_WINDOW_SIZE]; /**< TCP application data buffer */
 178                         bool                   Direction; /**< Buffer transmission direction, either TCP_PACKETDIR_IN  or TCP_PACKETDIR_OUT */
 179                         bool                   Ready; /**< If data from host, indicates buffer ready to be read, otherwise indicates
 180                                                        *   buffer ready to be sent to the host
 181                                                        */
 182                         bool                   InUse; /**< Indicates if the buffer is locked to to the current direction, and cannot be changed */
 183                 } TCP_ConnectionBuffer_t;
 184
 185                 /** Type define for a TCP connection information structure. */
 186                 typedef struct
 187                 {
 188                         uint32_t               SequenceNumberIn; /**< Current TCP sequence number for host-to-device */
 189                         uint32_t               SequenceNumberOut; /**< Current TCP sequence number for device-to-host */
 190                         TCP_ConnectionBuffer_t Buffer; /**< Connection application data buffer */
 191                 } TCP_ConnectionInfo_t;
 192
 193                 /** Type define for a complete TCP connection state. */
 194                 typedef struct
 195                 {
 196                         uint16_t               Port; /**< Connection port number on the device */
 197                         uint16_t               RemotePort; /**< Connection port number on the host */
 198                         IP_Address_t           RemoteAddress; /**< Connection protocol IP address of the host */
 199                         TCP_ConnectionInfo_t   Info; /**< Connection information, including application buffer */
 200                         uint8_t                State; /**< Current connection state, a value from the \ref TCP_ConnectionStates_t enum */
 201                 } TCP_ConnectionState_t;
 202
 203                 /** Type define for a TCP port state. */
 204                 typedef struct
 205                 {
 206                         uint16_t               Port; /**< TCP port number on the device */
 207                         uint8_t                State; /**< Current port state, a value from the \ref TCP_PortStates_t enum */
 208                         void                   (*ApplicationHandler) (TCP_ConnectionState_t* ConnectionState,
 209                                                                       TCP_ConnectionBuffer_t* Buffer); /**< Port application handler */
 210                 } TCP_PortState_t;
 211
 212                 /** Type define for a TCP packet header. */
 213                 typedef struct
 214                 {
 215                         uint16_t               SourcePort; /**< Source port of the TCP packet */
 216                         uint16_t               DestinationPort; /**< Destination port of the TCP packet */
 217
 218                         uint32_t               SequenceNumber; /**< Data sequence number of the packet */
 219                         uint32_t               AcknowledgmentNumber; /**< Data acknowledgment number of the packet */
 220
 221                         unsigned               Reserved : 4; /**< Reserved, must be all 0 */
 222                         unsigned               DataOffset : 4; /**< Offset of the data from the start of the header, in 4 byte chunks */
 223                         uint8_t                Flags; /**< TCP packet flags */
 224                         uint16_t               WindowSize; /**< Current data window size (bytes remaining in reception buffer) */
 225
 226                         uint16_t               Checksum; /**< TCP checksum */
 227                         uint16_t               UrgentPointer; /**< Urgent data pointer */
 228                 } TCP_Header_t;
 229
 230         /* Function Prototypes: */
 231                 void                  TCP_TCPTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,
 232                                                   Ethernet_Frame_Info_t* const FrameOUT);
 233                 void                  TCP_Init(void);
 234                 bool                  TCP_SetPortState(const uint16_t Port,
 235                                                        const uint8_t State,
 236                                                        void (*Handler)(TCP_ConnectionState_t*, TCP_ConnectionBuffer_t*));
 237                 uint8_t               TCP_GetPortState(const uint16_t Port);
 238                 bool                  TCP_SetConnectionState(const uint16_t Port,
 239                                                              const IP_Address_t* RemoteAddress,
 240                                                              const uint16_t RemotePort,
 241                                                              const uint8_t State);
 242                 uint8_t               TCP_GetConnectionState(const uint16_t Port,
 243                                                              const IP_Address_t* RemoteAddress,
 244                                                              const uint16_t RemotePort);
 245                 TCP_ConnectionInfo_t* TCP_GetConnectionInfo(const uint16_t Port,
 246                                                             const IP_Address_t* RemoteAddress,
 247                                                             const uint16_t RemotePort);
 248                 int16_t               TCP_ProcessTCPPacket(void* IPHeaderInStart,
 249                                                            void* TCPHeaderInStart,
 250                                                            void* TCPHeaderOutStart);
 251
 252                 #if defined(INCLUDE_FROM_TCP_C)
 253                         static uint16_t TCP_Checksum16(void* TCPHeaderOutStart,
 254                                                        const IP_Address_t* SourceAddress,
 255                                                        const IP_Address_t* DestinationAddress,
 256                                                        uint16_t TCPOutSize);
 257                 #endif
 258
 259 #endif
 260