Projects/Webserver/Lib/uIPManagement.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  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 disclaim 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  *  uIP Management functions. This file contains the functions and globals needed to maintain the uIP
  34  *  stack once an RNDIS device has been attached to the system.
  35  */
  36
  37 #define  INCLUDE_FROM_UIPMANAGEMENT_C
  38 #include "uIPManagement.h"
  39
  40 /** Connection timer, to retain the time elapsed since the last time the uIP connections were managed. */
  41 struct timer ConnectionTimer;
  42
  43 /** ARP timer, to retain the time elapsed since the ARP cache was last updated. */
  44 struct timer ARPTimer;
  45
  46 /** MAC address of the RNDIS device, when enumerated */
  47 struct uip_eth_addr MACAddress;
  48
  49 bool HaveIPConfiguration;
  50
  51 /** Configures the uIP stack ready for network traffic. */
  52 void uIPManagement_Init(void)
  53 {
  54         /* uIP Timing Initialization */
  55         clock_init();
  56         timer_set(&ConnectionTimer, CLOCK_SECOND / 2);
  57         timer_set(&ARPTimer, CLOCK_SECOND * 10);
  58
  59         /* uIP Stack Initialization */
  60         uip_init();
  61         uip_arp_init();
  62         uip_setethaddr(MACAddress);
  63
  64         /* DHCP/Server IP Settings Initialization */
  65         #if defined(ENABLE_DHCP_CLIENT)
  66         HaveIPConfiguration = false;
  67         DHCPClientApp_Init();
  68         #else
  69         HaveIPConfiguration = true;
  70         uip_ipaddr_t IPAddress, Netmask, GatewayIPAddress;
  71         uip_ipaddr(&IPAddress,        DEVICE_IP_ADDRESS[0], DEVICE_IP_ADDRESS[1], DEVICE_IP_ADDRESS[2], DEVICE_IP_ADDRESS[3]);
  72         uip_ipaddr(&Netmask,          DEVICE_NETMASK[0],    DEVICE_NETMASK[1],    DEVICE_NETMASK[2],    DEVICE_NETMASK[3]);
  73         uip_ipaddr(&GatewayIPAddress, DEVICE_GATEWAY[0],    DEVICE_GATEWAY[1],    DEVICE_GATEWAY[2],    DEVICE_GATEWAY[3]);
  74         uip_sethostaddr(&IPAddress);
  75         uip_setnetmask(&Netmask);
  76         uip_setdraddr(&GatewayIPAddress);
  77         #endif
  78
  79         /* HTTP Webserver Initialization */
  80         HTTPServerApp_Init();
  81
  82         /* TELNET Server Initialization */
  83         TELNETServerApp_Init();
  84 }
  85
  86 /** uIP Management function. This function manages the uIP stack when called while an RNDIS device has been
  87  *  attached to the system.
  88  */
  89 void uIPManagement_ManageNetwork(void)
  90 {
  91         if ((USB_CurrentMode == USB_MODE_HOST) && (USB_HostState == HOST_STATE_Configured))
  92         {
  93                 uIPManagement_ProcessIncomingPacket();
  94                 uIPManagement_ManageConnections();
  95         }
  96 }
  97
  98 /** uIP TCP/IP network stack callback function for the processing of a given TCP connection. This routine dispatches
  99  *  to the appropriate TCP protocol application based on the connection's listen port number.
 100  */
 101 void uIPManagement_TCPCallback(void)
 102 {
 103         /* Call the correct TCP application based on the port number the connection is listening on */
 104         switch (uip_conn->lport)
 105         {
 106                 case HTONS(HTTP_SERVER_PORT):
 107                         HTTPServerApp_Callback();
 108                         break;
 109                 case HTONS(TELNET_SERVER_PORT):
 110                         TELNETServerApp_Callback();
 111                         break;
 112         }
 113 }
 114
 115 /** uIP TCP/IP network stack callback function for the processing of a given UDP connection. This routine dispatches
 116  *  to the appropriate UDP protocol application based on the connection's listen port number.
 117  */
 118 void uIPManagement_UDPCallback(void)
 119 {
 120         /* Call the correct UDP application based on the port number the connection is listening on */
 121         switch (uip_udp_conn->lport)
 122         {
 123                 case HTONS(DHCPC_CLIENT_PORT):
 124                         DHCPClientApp_Callback();
 125                         break;
 126         }
 127 }
 128
 129 /** Processes Incoming packets to the server from the connected RNDIS device, creating responses as needed. */
 130 static void uIPManagement_ProcessIncomingPacket(void)
 131 {
 132         /* If no packet received, exit processing routine */
 133         if (!(RNDIS_Host_IsPacketReceived(&Ethernet_RNDIS_Interface)))
 134           return;
 135
 136         LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 137
 138         /* Read the Incoming packet straight into the UIP packet buffer */
 139         RNDIS_Host_ReadPacket(&Ethernet_RNDIS_Interface, uip_buf, &uip_len);
 140
 141         /* If the packet contains an Ethernet frame, process it */
 142         if (uip_len > 0)
 143         {
 144                 switch (((struct uip_eth_hdr*)uip_buf)->type)
 145                 {
 146                         case HTONS(UIP_ETHTYPE_IP):
 147                                 /* Filter packet by MAC destination */
 148                                 uip_arp_ipin();
 149
 150                                 /* Process Incoming packet */
 151                                 uip_input();
 152
 153                                 /* If a response was generated, send it */
 154                                 if (uip_len > 0)
 155                                 {
 156                                         /* Add destination MAC to outgoing packet */
 157                                         uip_arp_out();
 158
 159                                         uip_split_output();
 160                                 }
 161
 162                                 break;
 163                         case HTONS(UIP_ETHTYPE_ARP):
 164                                 /* Process ARP packet */
 165                                 uip_arp_arpin();
 166
 167                                 /* If a response was generated, send it */
 168                                 if (uip_len > 0)
 169                                   uip_split_output();
 170
 171                                 break;
 172                 }
 173         }
 174
 175         LEDs_SetAllLEDs(LEDMASK_USB_READY | ((HaveIPConfiguration) ? LEDMASK_UIP_READY_CONFIG : LEDMASK_UIP_READY_NOCONFIG));
 176 }
 177
 178 /** Manages the currently open network connections, including TCP and (if enabled) UDP. */
 179 static void uIPManagement_ManageConnections(void)
 180 {
 181         /* Poll TCP connections for more data to send back to the host */
 182         for (uint8_t i = 0; i < UIP_CONNS; i++)
 183         {
 184                 uip_poll_conn(&uip_conns[i]);
 185
 186                 /* If a response was generated, send it */
 187                 if (uip_len > 0)
 188                 {
 189                         /* Add destination MAC to outgoing packet */
 190                         uip_arp_out();
 191
 192                         /* Split and send the outgoing packet */
 193                         uip_split_output();
 194                 }
 195         }
 196
 197         /* Manage open connections for timeouts */
 198         if (timer_expired(&ConnectionTimer))
 199         {
 200                 timer_reset(&ConnectionTimer);
 201
 202                 LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 203
 204                 for (uint8_t i = 0; i < UIP_CONNS; i++)
 205                 {
 206                         /* Run periodic connection management for each TCP connection */
 207                         uip_periodic(i);
 208
 209                         /* If a response was generated, send it */
 210                         if (uip_len > 0)
 211                         {
 212                                 /* Add destination MAC to outgoing packet */
 213                                 uip_arp_out();
 214
 215                                 /* Split and send the outgoing packet */
 216                                 uip_split_output();
 217                         }
 218                 }
 219
 220                 #if defined(ENABLE_DHCP_CLIENT)
 221                 for (uint8_t i = 0; i < UIP_UDP_CONNS; i++)
 222                 {
 223                         /* Run periodic connection management for each UDP connection */
 224                         uip_udp_periodic(i);
 225
 226                         /* If a response was generated, send it */
 227                         if (uip_len > 0)
 228                         {
 229                                 /* Add destination MAC to outgoing packet */
 230                                 uip_arp_out();
 231
 232                                 /* Split and send the outgoing packet */
 233                                 uip_split_output();
 234                         }
 235                 }
 236                 #endif
 237
 238                 LEDs_SetAllLEDs(LEDMASK_USB_READY);
 239         }
 240
 241         /* Manage ARP cache refreshing */
 242         if (timer_expired(&ARPTimer))
 243         {
 244                 timer_reset(&ARPTimer);
 245                 uip_arp_timer();
 246         }
 247 }