phone-side
/
nuttx-bb
9
0
Fork 0
Code Releases Activity

Associate address with network driver; implement ioctl calls to set addresses 

git-svn-id: https://nuttx.svn.sourceforge.net/svnroot/nuttx/trunk@345 7fd9a85b-ad96-42d3-883c-3090e2eb8679
This commit is contained in:
patacongo 2007-09-16 22:12:04 +00:00
parent b185533aba
commit 702355cea2
28 changed files with 893 additions and 429 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
nuttx/ChangeLog
View File

@ -210,4 +210,6 @@
* Added getsockopt() and setsockopt() * Added getsockopt() and setsockopt()
* Documentation updated to address socket interfaces. * Documentation updated to address socket interfaces.
* Implemented receive timeouts via setsockopt(SO_RCVTIMEO). * Implemented receive timeouts via setsockopt(SO_RCVTIMEO).
* Provide support for multiple network devices
* Implement socket ioctl() calls to set addresses

2
nuttx/Documentation/NuttX.html
View File

@ -643,6 +643,8 @@ Other memory:
* Added getsockopt() and setsockopt() * Added getsockopt() and setsockopt()
* Documentation updated to address socket interfaces. * Documentation updated to address socket interfaces.
* Implemented receive timeouts via setsockopt(SO_RCVTIMEO). * Implemented receive timeouts via setsockopt(SO_RCVTIMEO).
* Provide support for multiple network devices
* Implement socket ioctl() calls to set addresses
</pre></ul> </pre></ul>
<table width ="100%"> <table width ="100%">

1
nuttx/arch/sim/src/up_uipdriver.c
View File

@ -44,6 +44,7 @@
#include <nuttx/config.h> #include <nuttx/config.h>
#include <sys/types.h> #include <sys/types.h>
#include <nuttx/net.h>
#include <net/uip/uip.h> #include <net/uip/uip.h>
#include <net/uip/uip-arch.h> #include <net/uip/uip-arch.h>

16
nuttx/examples/uip/main.c
View File

@ -72,6 +72,7 @@
int user_start(int argc, char *argv[]) int user_start(int argc, char *argv[])
{ {
struct in_addr addr;
uip_ipaddr_t ipaddr; uip_ipaddr_t ipaddr;
#if defined(CONFIG_EXAMPLE_UIP_DHCPC) #if defined(CONFIG_EXAMPLE_UIP_DHCPC)
uint16 mac[6] = {1, 2, 3, 4, 5, 6}; uint16 mac[6] = {1, 2, 3, 4, 5, 6};
@ -80,12 +81,13 @@ int user_start(int argc, char *argv[])
void *handle; void *handle;
#endif #endif
uip_ipaddr(ipaddr, 192, 168, 0, 2); addr.s_addr = htonl( 192 << 24 | 168 << 16 | 0 << 8 | 2 );
uip_sethostaddr(ipaddr); uip_sethostaddr("eth0", &addr);
uip_ipaddr(ipaddr, 192, 168, 0, 1); uip_ipaddr(ipaddr, 192, 168, 0, 1);
uip_setdraddr(ipaddr); uip_setdraddr("eth0", &ipaddr);
uip_ipaddr(ipaddr, 255, 255, 255, 0); uip_ipaddr(ipaddr, 255, 255, 255, 0);
uip_setnetmask(ipaddr); uip_setnetmask("eth0", &ipaddr);
#if defined(CONFIG_EXAMPLE_UIP_WEBSERVER) #if defined(CONFIG_EXAMPLE_UIP_WEBSERVER)
httpd_init(); httpd_init();
@ -99,9 +101,9 @@ int user_start(int argc, char *argv[])
{ {
struct dhcpc_state ds; struct dhcpc_state ds;
(void)dhcpc_request(handle, &ds); (void)dhcpc_request(handle, &ds);
uip_sethostaddr(ds.ipaddr); uip_sethostaddr("eth0", &ds.ipaddr);
uip_setnetmask(ds.netmask); uip_setnetmask("eth0", &ds.netmask);
uip_setdraddr(ds.default_router); uip_setdraddr("eth0", &ds.default_router);
resolv_conf(ds.dnsaddr); resolv_conf(ds.dnsaddr);
dhcpc_close(handle); dhcpc_close(handle);
} }

5
nuttx/include/arpa/inet.h
View File

@ -63,8 +63,9 @@
#else #else
# define HTONS(ns) \ # define HTONS(ns) \
(uint16)((((uint16) (ns)) << 8) | (((uint16) (ns)) >> 8)) (uint16)((((uint16) (ns)) << 8) | (((uint16) (ns)) >> 8))
# define HTONL(nl) htonl(nl) \ # define HTONL(nl) \
(((uint32)HTONS((uint16)((hs) & 0xffff)) << 16) | (uint32)HTONS((uint16)((uint16)((hs) >> 16)))) ((((nl) & 0xff) << 24) | (((nl) & 0xff00) << 8) | \
(((nl) & 0xff0000) >> 8) | (((nl) & 0xff000000) >> 24))
#endif #endif
#define NTOHS(hs) HTONS(hs) #define NTOHS(hs) HTONS(hs)

24
nuttx/include/net/ioctls.h
View File

@ -57,15 +57,17 @@
#define SIOCGIFADDR (_SIOCBASE|0x0001) /* Get IP address */ #define SIOCGIFADDR (_SIOCBASE|0x0001) /* Get IP address */
#define SIOCSIFADDR (_SIOCBASE|0x0002) /* Set IP address */ #define SIOCSIFADDR (_SIOCBASE|0x0002) /* Set IP address */
#define SIOCGIFBRDADDR (_SIOCBASE|0x0003) /* Get broadcast IP address */ #define SIOCGIFDSTADDR (_SIOCBASE|0x0003) /* Get P-to-P address */
#define SIOCSIFBRDADDR (_SIOCBASE|0x0004) /* Set broadcast IP address */ #define SIOCSIFDSTADDR (_SIOCBASE|0x0004) /* Set P-to-P address */
#define SIOCGIFNETMASK (_SIOCBASE|0x0005) /* Get network mask */ #define SIOCGIFBRDADDR (_SIOCBASE|0x0005) /* Get broadcast IP address */
#define SIOCSIFNETMASK (_SIOCBASE|0x0006) /* Set network mask */ #define SIOCSIFBRDADDR (_SIOCBASE|0x0006) /* Set broadcast IP address */
#define SIOCGIFMTU (_SIOCBASE|0x0007) /* Get MTU size */ #define SIOCGIFNETMASK (_SIOCBASE|0x0007) /* Get network mask */
#define SIOCSIFHWADDR (_SIOCBASE|0x0008) /* Set hardware address */ #define SIOCSIFNETMASK (_SIOCBASE|0x0008) /* Set network mask */
#define SIOCGIFHWADDR (_SIOCBASE|0x0009) /* Get hardware address */ #define SIOCGIFMTU (_SIOCBASE|0x0009) /* Get MTU size */
#define SIOCDIFADDR (_SIOCBASE|0x000a) /* Delete IP address */ #define SIOCGIFHWADDR (_SIOCBASE|0x000a) /* Get hardware address */
#define SIOCGIFCOUNT (_SIOCBASE|0x000b) /* Get number of devices */ #define SIOCSIFHWADDR (_SIOCBASE|0x000b) /* Set hardware address */
#define SIOCDIFADDR (_SIOCBASE|0x000c) /* Delete IP address */
#define SIOCGIFCOUNT (_SIOCBASE|0x000d) /* Get number of devices */
/* Sizing parameters */ /* Sizing parameters */
@ -82,6 +84,7 @@ struct ifreq
union union
{ {
struct sockaddr ifru_addr; /* IP Address */ struct sockaddr ifru_addr; /* IP Address */
struct sockaddr ifru_dstaddr; /* P-to-P Address */
struct sockaddr ifru_broadaddr; /* Broadcast address */ struct sockaddr ifru_broadaddr; /* Broadcast address */
struct sockaddr ifru_netmask; /* Netmask */ struct sockaddr ifru_netmask; /* Netmask */
struct sockaddr ifru_hwaddr; /* MAC address */ struct sockaddr ifru_hwaddr; /* MAC address */
@ -90,7 +93,8 @@ struct ifreq
} ifr_ifru; } ifr_ifru;
}; };
#define ifr_addr ifr_ifru.ifru_addr /* Address */ #define ifr_addr ifr_ifru.ifru_addr /* IP address */
#define ifr_dstaddr ifr_ifru.ifru_dstaddr /* P-to-P Address */
#define ifr_broadaddr ifr_ifru.ifru_broadaddr /* Broadcast address */ #define ifr_broadaddr ifr_ifru.ifru_broadaddr /* Broadcast address */
#define ifr_netmask ifr_ifru.ifru_netmask /* Interface net mask */ #define ifr_netmask ifr_ifru.ifru_netmask /* Interface net mask */
#define ifr_hwaddr ifr_ifru.ifru_hwaddr /* MAC address */ #define ifr_hwaddr ifr_ifru.ifru_hwaddr /* MAC address */

10
nuttx/include/net/uip/uip-arch.h
View File

@ -101,6 +101,16 @@ struct uip_driver_s
char d_ifname[IFNAMSIZ]; char d_ifname[IFNAMSIZ];
#endif #endif
/* Device identitity */
struct uip_eth_addr d_mac; /* Device MAC address */
/* Network identity */
uip_ipaddr_t d_ipaddr; /* Host IP address assigned to the network interface */
uip_ipaddr_t d_draddr; /* Default router IP address */
uip_ipaddr_t d_netmask; /* Network subnet mask */
/* The d_buf array is used to hold incoming and outgoing /* The d_buf array is used to hold incoming and outgoing
* packets. The device driver should place incoming data into this * packets. The device driver should place incoming data into this
* buffer. When sending data, the device driver should read the link * buffer. When sending data, the device driver should read the link

23
nuttx/include/net/uip/uip-arp.h
View File

@ -37,8 +37,6 @@
#include <sys/types.h> #include <sys/types.h>
#include <net/uip/uip.h> #include <net/uip/uip.h>
extern struct uip_eth_addr uip_ethaddr;
/* The Ethernet header */ /* The Ethernet header */
struct uip_eth_hdr struct uip_eth_hdr
@ -97,25 +95,4 @@ void uip_arp_out(struct uip_driver_s *dev);
void uip_arp_timer(void); void uip_arp_timer(void);
/* Specifiy the Ethernet MAC address.
*
* The ARP code needs to know the MAC address of the Ethernet card in
* order to be able to respond to ARP queries and to generate working
* Ethernet headers.
*
* Note: This macro only specifies the Ethernet MAC address to the ARP
* code. It cannot be used to change the MAC address of the Ethernet
* card.
*
* eaddr A pointer to a struct uip_eth_addr containing the
* Ethernet MAC address of the Ethernet card.
*/
#define uip_setethaddr(eaddr) do {uip_ethaddr.addr[0] = eaddr.addr[0]; \
uip_ethaddr.addr[1] = eaddr.addr[1];\
uip_ethaddr.addr[2] = eaddr.addr[2];\
uip_ethaddr.addr[3] = eaddr.addr[3];\
uip_ethaddr.addr[4] = eaddr.addr[4];\
uip_ethaddr.addr[5] = eaddr.addr[5];} while(0)
#endif /* __UIP_ARP_H__ */ #endif /* __UIP_ARP_H__ */

137
nuttx/include/net/uip/uip.h
View File

@ -141,7 +141,7 @@
/* Repressentation of an IP address. */ /* Repressentation of an IP address. */
typedef uint16 uip_ip4addr_t[2]; typedef in_addr_t uip_ip4addr_t;
typedef uint16 uip_ip6addr_t[8]; typedef uint16 uip_ip6addr_t[8];
#ifdef CONFIG_NET_IPv6 #ifdef CONFIG_NET_IPv6
@ -282,12 +282,13 @@ struct uip_tcpip_hdr
/* IPv6 header. */ /* IPv6 header. */
uint8 vtc; uint8 vtc;
uint8 tcflow; uint8 tcflow;
uint16 flow; uint16 flow;
uint8 len[2]; uint8 len[2];
uint8 proto, ttl; uint8 proto, ttl;
uip_ip6addr_t srcipaddr, destipaddr; uip_ip6addr_t srcipaddr;
uip_ip6addr_t destipaddr;
#else /* CONFIG_NET_IPv6 */ #else /* CONFIG_NET_IPv6 */
@ -301,8 +302,8 @@ struct uip_tcpip_hdr
uint8 ttl; uint8 ttl;
uint8 proto; uint8 proto;
uint16 ipchksum; uint16 ipchksum;
uint16 srcipaddr[2]; in_addr_t srcipaddr;
uint16 destipaddr[2]; in_addr_t destipaddr;
#endif /* CONFIG_NET_IPv6 */ #endif /* CONFIG_NET_IPv6 */
@ -349,8 +350,8 @@ struct uip_icmpip_hdr
uint8 ttl; uint8 ttl;
uint8 proto; uint8 proto;
uint16 ipchksum; uint16 ipchksum;
uint16 srcipaddr[2]; in_addr_t srcipaddr;
uint16 destipaddr[2]; in_addr_t destipaddr;
#endif /* CONFIG_NET_IPv6 */ #endif /* CONFIG_NET_IPv6 */
@ -405,8 +406,8 @@ struct uip_udpip_hdr
uint8 ttl; uint8 ttl;
uint8 proto; uint8 proto;
uint16 ipchksum; uint16 ipchksum;
uint16 srcipaddr[2]; in_addr_t srcipaddr;
uint16 destipaddr[2]; in_addr_t destipaddr;
#endif /* CONFIG_NET_IPv6 */ #endif /* CONFIG_NET_IPv6 */
@ -483,88 +484,11 @@ extern struct uip_stats uip_stat;
extern uint8 uip_flags; extern uint8 uip_flags;
#if UIP_FIXEDADDR
extern const uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
#else /* UIP_FIXEDADDR */
extern uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
#endif /* UIP_FIXEDADDR */
/**************************************************************************** /****************************************************************************
* Public Function Prototypes * Public Function Prototypes
****************************************************************************/ ****************************************************************************/
/* uIP configuration functions /* uIP configuration functions */
*
* The uIP configuration functions are used for setting run-time
* parameters in uIP such as IP addresses.
*
* Set the IP address of this host.
*
* The IP address is represented as a 4-byte array where the first
* octet of the IP address is put in the first member of the 4-byte
* array.
*
* Example:
*
* uip_ipaddr_t addr;
*
* uip_ipaddr(&addr, 192,168,1,2);
* uip_sethostaddr(&addr);
*
* addr A pointer to an IP address of type uip_ipaddr_t;
*/
#define uip_sethostaddr(addr) uip_ipaddr_copy(uip_hostaddr, (addr))
/* Get the IP address of this host.
*
* The IP address is represented as a 4-byte array where the first
* octet of the IP address is put in the first member of the 4-byte
* array.
*
* Example:
*
* uip_ipaddr_t hostaddr;
*
* uip_gethostaddr(&hostaddr);
*
* addr A pointer to a uip_ipaddr_t variable that will be
* filled in with the currently configured IP address.
*/
#define uip_gethostaddr(addr) uip_ipaddr_copy((addr), uip_hostaddr)
/* Set the default router's IP address.
*
* addr A pointer to a uip_ipaddr_t variable containing the IP
* address of the default router.
*/
#define uip_setdraddr(addr) uip_ipaddr_copy(uip_draddr, (addr))
/* Set the netmask.
*
* addr A pointer to a uip_ipaddr_t variable containing the IP
* address of the netmask.
*/
#define uip_setnetmask(addr) uip_ipaddr_copy(uip_netmask, (addr))
/* Get the default router's IP address.
*
* addr A pointer to a uip_ipaddr_t variable that will be
* filled in with the IP address of the default router.
*/
#define uip_getdraddr(addr) uip_ipaddr_copy((addr), uip_draddr)
/* Get the netmask.
*
* addr A pointer to a uip_ipaddr_t variable that will be
* filled in with the value of the netmask.
*/
#define uip_getnetmask(addr) uip_ipaddr_copy((addr), uip_netmask)
/* uIP initialization functions /* uIP initialization functions
* *
@ -906,8 +830,7 @@ extern void uip_udpdisable(struct uip_udp_conn *conn);
#define uip_ipaddr(addr, addr0, addr1, addr2, addr3) \ #define uip_ipaddr(addr, addr0, addr1, addr2, addr3) \
do { \ do { \
((uint16 *)(addr))[0] = HTONS(((addr0) << 8) | (addr1)); \ addr = HTONL((addr0) << 24 | (addr1) << 16 | (addr2) << 8 | (addr3)); \
((uint16 *)(addr))[1] = HTONS(((addr2) << 8) | (addr3)); \
} while(0) } while(0)
/* Construct an IPv6 address from eight 16-bit words. /* Construct an IPv6 address from eight 16-bit words.
@ -942,12 +865,12 @@ extern void uip_udpdisable(struct uip_udp_conn *conn);
*/ */
#ifndef CONFIG_NET_IPv6 #ifndef CONFIG_NET_IPv6
#define uip_ipaddr_copy(dest, src) do { \ #define uip_ipaddr_copy(dest, src) \
((uint16 *)dest)[0] = ((uint16 *)src)[0]; \ do { \
((uint16 *)dest)[1] = ((uint16 *)src)[1]; \ (dest) = (in_addr_t)(src); \
} while(0) } while(0)
#else /* !CONFIG_NET_IPv6 */ #else /* !CONFIG_NET_IPv6 */
#define uip_ipaddr_copy(dest, src) memcpy(dest, src, sizeof(uip_ip6addr_t)) #define uip_ipaddr_copy(dest, src) memcpy(&dest, &src, sizeof(uip_ip6addr_t))
#endif /* !CONFIG_NET_IPv6 */ #endif /* !CONFIG_NET_IPv6 */
/* Compare two IP addresses /* Compare two IP addresses
@ -972,8 +895,7 @@ extern void uip_udpdisable(struct uip_udp_conn *conn);
#define uip_ipaddr_cmp(addr1, addr2) (memcmp(addr1, addr2, sizeof(uip_ip6addr_t)) == 0) #define uip_ipaddr_cmp(addr1, addr2) (memcmp(addr1, addr2, sizeof(uip_ip6addr_t)) == 0)
#endif /* !CONFIG_NET_IPv6 */ #endif /* !CONFIG_NET_IPv6 */
/** /* Compare two IP addresses with netmasks
* Compare two IP addresses with netmasks
* *
* Compares two IP addresses with netmasks. The masks are used to mask * Compares two IP addresses with netmasks. The masks are used to mask
* out the bits that are to be compared. * out the bits that are to be compared.
@ -995,14 +917,9 @@ extern void uip_udpdisable(struct uip_udp_conn *conn);
*/ */
#define uip_ipaddr_maskcmp(addr1, addr2, mask) \ #define uip_ipaddr_maskcmp(addr1, addr2, mask) \
(((((uint16 *)addr1)[0] & ((uint16 *)mask)[0]) == \ (((in_addr_t)addr1 & (in_addr_t)mask) == ((in_addr_t)addr2 & (in_addr_t)mask))
(((uint16 *)addr2)[0] & ((uint16 *)mask)[0])) && \
((((uint16 *)addr1)[1] & ((uint16 *)mask)[1]) == \
(((uint16 *)addr2)[1] & ((uint16 *)mask)[1])))
/* Mask out the network part of an IP address.
/**
* Mask out the network part of an IP address.
* *
* Masks out the network part of an IP address, given the address and * Masks out the network part of an IP address, given the address and
* the netmask. * the netmask.
@ -1023,10 +940,10 @@ extern void uip_udpdisable(struct uip_udp_conn *conn);
* mask The netmask. * mask The netmask.
*/ */
#define uip_ipaddr_mask(dest, src, mask) do { \ #define uip_ipaddr_mask(dest, src, mask) \
((uint16 *)dest)[0] = ((uint16 *)src)[0] & ((uint16 *)mask)[0]; \ do { \
((uint16 *)dest)[1] = ((uint16 *)src)[1] & ((uint16 *)mask)[1]; \ (in_addr_t)(dest) = (in_addr_t)(src) & (in_addr_t)(mask); \
} while(0) } while(0)
/* Pick the first octet of an IP address. /* Pick the first octet of an IP address.
* *

32
nuttx/include/net/uip/uipopt.h
View File

@ -69,26 +69,7 @@
* Public Type Definitions * Public Type Definitions
****************************************************************************/ ****************************************************************************/
/* Static configuration options /* Static configuration options */
*
* These configuration options can be used for setting the IP address
* settings statically, but only if UIP_FIXEDADDR is set to 1. The
* configuration options for a specific node includes IP address,
* netmask and default router as well as the Ethernet address. The
* netmask, default router and Ethernet address are appliciable only
* if uIP should be run over Ethernet.
*
* All of these should be changed to suit your project.
*/
/* Determines if uIP should use a fixed IP address or not.
*
* If uIP should use a fixed IP address, the settings are set in the
* uipopt.h file. If not, the macros uip_sethostaddr(),
* uip_setdraddr() and uip_setnetmask() should be used instead.
*/
#define UIP_FIXEDADDR 0
/* Ping IP address asignment. /* Ping IP address asignment.
* *
@ -96,8 +77,6 @@
* option is set. If so, uIP will start with an empty IP address and * option is set. If so, uIP will start with an empty IP address and
* the destination IP address of the first incoming "ping" (ICMP echo) * the destination IP address of the first incoming "ping" (ICMP echo)
* packet will be used for setting the hosts IP address. * packet will be used for setting the hosts IP address.
*
* Note: This works only if UIP_FIXEDADDR is 0.
*/ */
#ifdef CONFIG_NET_PINGADDRCONF #ifdef CONFIG_NET_PINGADDRCONF
@ -106,15 +85,6 @@
#define UIP_PINGADDRCONF 0 #define UIP_PINGADDRCONF 0
#endif /* CONFIG_NET_PINGADDRCONF */ #endif /* CONFIG_NET_PINGADDRCONF */
/* Specifies if the uIP ARP module should be compiled with a fixed
* Ethernet MAC address or not.
*
* If this configuration option is 0, the macro uip_setethaddr() can
* be used to specify the Ethernet address at run-time.
*/
#define UIP_FIXEDETHADDR 0
/* IP configuration options */ /* IP configuration options */
/* The IP TTL (time to live) of IP packets sent by uIP. /* The IP TTL (time to live) of IP packets sent by uIP.

2
nuttx/net/Makefile
View File

@ -51,7 +51,7 @@ endif
endif endif
NETDEV_ASRCS = NETDEV_ASRCS =
NETDEV_CSRCS = netdev-register.c netdev-ioctl.c netdev-find.c NETDEV_CSRCS = netdev-register.c netdev-ioctl.c netdev-find.c netdev-count.c
include uip/Make.defs include uip/Make.defs
endif endif

8
nuttx/net/net-internal.h
View File

@ -165,7 +165,13 @@ EXTERN void netdev_semtake(void);
/* net-find.c ****************************************************************/ /* net-find.c ****************************************************************/
#if CONFIG_NSOCKET_DESCRIPTORS > 0 #if CONFIG_NSOCKET_DESCRIPTORS > 0
FAR struct uip_driver_s *netdev_find(const char *ifname); EXTERN FAR struct uip_driver_s *netdev_find(const char *ifname);
#endif
/* net-count.c ***************************************************************/
#if CONFIG_NSOCKET_DESCRIPTORS > 0
EXTERN int netdev_count(void);
#endif #endif
#undef EXTERN #undef EXTERN

2
nuttx/net/net-sockets.c
View File

@ -272,4 +272,4 @@ FAR struct socket *sockfd_socket(int sockfd)
} }
#endif /* CONFIG_NSOCKET_DESCRIPTORS */ #endif /* CONFIG_NSOCKET_DESCRIPTORS */
#endif /* CONFIG_NET */ #endif /* CONFIG_NET */

103
nuttx/net/netdev-count.c Normal file
View File

@ -0,0 +1,103 @@
/****************************************************************************
* net/netdev-count.c
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#if defined(CONFIG_NET) && CONFIG_NSOCKET_DESCRIPTORS > 0
#include <sys/types.h>
#include <string.h>
#include <errno.h>
#include <net/uip/uip-arch.h>
#include "net-internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
/****************************************************************************
* Priviate Types
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Global Functions
****************************************************************************/
/****************************************************************************
* Function: netdev_count
*
* Description:
* Return the number of network devices
*
* Parameters:
* None
*
* Returned Value:
* The number of network devices
*
* Assumptions:
* Called from normal user mode
*
****************************************************************************/
int netdev_count(void)
{
struct uip_driver_s *dev;
int ndev;
netdev_semtake();
for (dev = g_netdevices, ndev = 0; dev; dev = dev->flink, ndev++);
netdev_semgive();
return ndev;
}
#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

7
nuttx/net/netdev-find.c
View File

@ -41,6 +41,7 @@
#if defined(CONFIG_NET) && CONFIG_NSOCKET_DESCRIPTORS > 0 #if defined(CONFIG_NET) && CONFIG_NSOCKET_DESCRIPTORS > 0
#include <sys/types.h> #include <sys/types.h>
#include <string.h>
#include <errno.h> #include <errno.h>
#include <net/uip/uip-arch.h> #include <net/uip/uip-arch.h>
@ -59,16 +60,10 @@
* Private Data * Private Data
****************************************************************************/ ****************************************************************************/
static int g_next_devnum = 0;
/**************************************************************************** /****************************************************************************
* Public Data * Public Data
****************************************************************************/ ****************************************************************************/
/* List of registered ethernet device drivers */
struct uip_driver_s *g_netdevices;
sem_t g_netdev_sem;
/**************************************************************************** /****************************************************************************
* Private Functions * Private Functions
****************************************************************************/ ****************************************************************************/

148
nuttx/net/netdev-ioctl.c
View File

@ -42,11 +42,54 @@
#include <sys/types.h> #include <sys/types.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/ioctl.h>
#include <string.h>
#include <errno.h> #include <errno.h>
#include <nuttx/net.h> #include <nuttx/net.h>
#include <net/uip/uip-arch.h>
#include <net/uip/uip.h>
#include "net-internal.h" #include "net-internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: _get_ipaddr / _set_ipaddr
*
* Description:
* Copy IP addresses into and out of device structure
*
****************************************************************************/
static void _get_ipaddr(struct sockaddr *outaddr, uip_ipaddr_t *inaddr)
{
#ifdef CONFIG_NET_IPv6
struct sockaddr_in6 *dest = (struct sockaddr_in6 *)outaddr;
memcpy(&dest->sin6_addr.in6_u, inaddr, IFHWADDRLEN);
#else
struct sockaddr_in *dest = (struct sockaddr_in *)outaddr;
dest->sin_addr.s_addr = *inaddr;
#endif
}
static void _set_ipaddr(uip_ipaddr_t *outaddr, struct sockaddr *inaddr)
{
#ifdef CONFIG_NET_IPv6
struct sockaddr_in6 *src = (struct sockaddr_in6 *)inaddr;
memcpy(outaddr, &src->sin6_addr.in6_u, IFHWADDRLEN);
#else
struct sockaddr_in *src = (struct sockaddr_in *)inaddr;
*outaddr = src->sin_addr.s_addr;
#endif
}
/**************************************************************************** /****************************************************************************
* Global Functions * Global Functions
****************************************************************************/ ****************************************************************************/
@ -58,7 +101,7 @@
* Perform network device specific operations. * Perform network device specific operations.
* *
* Parameters: * Parameters:
* fd Socket descriptor of device * sockfd Socket descriptor of device
* cmd The ioctl command * cmd The ioctl command
* req The argument of the ioctl cmd * req The argument of the ioctl cmd
* *
@ -67,23 +110,112 @@
* -1 on failure withi errno set properly: * -1 on failure withi errno set properly:
* *
* EBADF * EBADF
* 'fd' is not a valid descriptor. * 'sockfd' is not a valid descriptor.
* EFAULT * EFAULT
* 'arg' references an inaccessible memory area. * 'req' references an inaccessible memory area.
* EINVAL * EINVAL
* 'cmd' or 'arg' is not valid. * 'cmd' or 'req' is not valid.
* ENOTTY * ENOTTY
* 'fd' is not associated with a character special device. * 'sockfd' is not associated with a network device.
* ENOTTY * ENOTTY
* The specified request does not apply to the kind of object that the * The specified request does not apply to the kind of object that the
* descriptor 'fd' references. * descriptor 'sockfd' references.
* *
****************************************************************************/ ****************************************************************************/
int netdev_ioctl(int sockfd, int cmd, struct ifreq *req) int netdev_ioctl(int sockfd, int cmd, struct ifreq *req)
{ {
#warning "Network ioctls not implemented" FAR struct socket *psock = sockfd_socket(sockfd);
*get_errno_ptr() = ENOSYS; FAR struct uip_driver_s *dev;
int err;
if (!_SIOCVALID(cmd) || !req)
{
err = EINVAL;
goto errout;
}
/* Verify that the sockfd corresponds to valid, allocated socket */
if (!psock || psock->s_crefs <= 0)
{
err = EBADF;
goto errout;
}
/* Find the network device associated with the device name
* in the request data.
*/
dev = netdev_find(req->ifr_name);
if (!dev)
{
err = EINVAL;
goto errout;
}
/* Execute the command */
switch (cmd)
{
case SIOCGIFADDR: /* Get IP address */
_get_ipaddr(&req->ifr_addr, &dev->d_ipaddr);
break;
case SIOCSIFADDR: /* Set IP address */
_set_ipaddr(&dev->d_ipaddr, &req->ifr_addr);
break;
case SIOCGIFDSTADDR: /* Get P-to-P address */
_get_ipaddr(&req->ifr_dstaddr, &dev->d_draddr);
break;
case SIOCSIFDSTADDR: /* Set P-to-P address */
_set_ipaddr(&dev->d_draddr, &req->ifr_dstaddr);
break;
case SIOCGIFNETMASK: /* Get network mask */
_get_ipaddr(&req->ifr_addr, &dev->d_netmask);
break;
case SIOCSIFNETMASK: /* Set network mask */
_set_ipaddr(&dev->d_netmask, &req->ifr_addr);
break;
case SIOCGIFMTU: /* Get MTU size */
req->ifr_mtu = UIP_BUFSIZE;
break;
case SIOCGIFHWADDR: /* Get hardware address */
memcpy(req->ifr_hwaddr.sa_data, dev->d_mac.addr, IFHWADDRLEN);
break;
case SIOCSIFHWADDR: /* Set hardware address */
memcpy(dev->d_mac.addr, req->ifr_hwaddr.sa_data, IFHWADDRLEN);
break;
case SIOCDIFADDR: /* Delete IP address */
memset(&dev->d_ipaddr, 0, sizeof(uip_ipaddr_t));
break;
case SIOCGIFCOUNT: /* Get number of devices */
req->ifr_count = netdev_count();
break;
case SIOCGIFBRDADDR: /* Get broadcast IP address */
case SIOCSIFBRDADDR: /* Set broadcast IP address */
err = ENOSYS;
goto errout;
default:
err = EINVAL;
goto errout;
}
return OK;
errout:
*get_errno_ptr() = err;
return ERROR; return ERROR;
} }

102
nuttx/net/uip/uip-arp.c
View File

@ -40,7 +40,9 @@
*/ */
#include <sys/types.h> #include <sys/types.h>
#include <sys/ioctl.h>
#include <string.h> #include <string.h>
#include <netinet/in.h>
#include <net/uip/uip-arch.h> #include <net/uip/uip-arch.h>
#include <net/uip/uip-arp.h> #include <net/uip/uip-arp.h>
@ -53,24 +55,27 @@ struct arp_hdr
uint8 protolen; uint8 protolen;
uint16 opcode; uint16 opcode;
struct uip_eth_addr shwaddr; struct uip_eth_addr shwaddr;
uint16 sipaddr[2]; in_addr_t sipaddr;
struct uip_eth_addr dhwaddr; struct uip_eth_addr dhwaddr;
uint16 dipaddr[2]; in_addr_t dipaddr;
}; };
struct ethip_hdr { struct ethip_hdr
{
struct uip_eth_hdr ethhdr; struct uip_eth_hdr ethhdr;
/* IP header. */ /* IP header. */
uint8 vhl,
tos, uint8 vhl;
len[2], uint8 tos;
ipid[2], uint8 len[2];
ipoffset[2], uint8 ipid[2];
ttl, uint8 ipoffset[2];
proto; uint8 ttl;
uint8 proto;
uint16 ipchksum; uint16 ipchksum;
uint16 srcipaddr[2], in_addr_t srcipaddr;
destipaddr[2]; in_addr_t destipaddr;
}; };
#define ARP_REQUEST 1 #define ARP_REQUEST 1
@ -78,8 +83,9 @@ struct ethip_hdr {
#define ARP_HWTYPE_ETH 1 #define ARP_HWTYPE_ETH 1
struct arp_entry { struct arp_entry
uint16 ipaddr[2]; {
in_addr_t ipaddr;
struct uip_eth_addr ethaddr; struct uip_eth_addr ethaddr;
uint8 time; uint8 time;
}; };
@ -89,7 +95,7 @@ static const struct uip_eth_addr broadcast_ethaddr =
static const uint16 broadcast_ipaddr[2] = {0xffff,0xffff}; static const uint16 broadcast_ipaddr[2] = {0xffff,0xffff};
static struct arp_entry arp_table[UIP_ARPTAB_SIZE]; static struct arp_entry arp_table[UIP_ARPTAB_SIZE];
static uint16 ipaddr[2]; static in_addr_t ipaddr;
static uint8 i, c; static uint8 i, c;
static uint8 arptime; static uint8 arptime;
@ -104,7 +110,7 @@ void uip_arp_init(void)
{ {
for (i = 0; i < UIP_ARPTAB_SIZE; ++i) for (i = 0; i < UIP_ARPTAB_SIZE; ++i)
{ {
memset(arp_table[i].ipaddr, 0, 4); memset(&arp_table[i].ipaddr, 0, sizeof(in_addr_t));
} }
} }
@ -123,14 +129,14 @@ void uip_arp_timer(void)
for (i = 0; i < UIP_ARPTAB_SIZE; ++i) for (i = 0; i < UIP_ARPTAB_SIZE; ++i)
{ {
tabptr = &arp_table[i]; tabptr = &arp_table[i];
if ((tabptr->ipaddr[0] | tabptr->ipaddr[1]) != 0 && arptime - tabptr->time >= UIP_ARP_MAXAGE) if (tabptr->ipaddr != 0 && arptime - tabptr->time >= UIP_ARP_MAXAGE)
{ {
memset(tabptr->ipaddr, 0, 4); tabptr->ipaddr = 0;
} }
} }
} }
static void uip_arp_update(uint16 *pipaddr, struct uip_eth_addr *ethaddr) static void uip_arp_update(in_addr_t pipaddr, struct uip_eth_addr *ethaddr)
{ {
struct arp_entry *tabptr; struct arp_entry *tabptr;
@ -145,16 +151,16 @@ static void uip_arp_update(uint16 *pipaddr, struct uip_eth_addr *ethaddr)
/* Only check those entries that are actually in use. */ /* Only check those entries that are actually in use. */
if (tabptr->ipaddr[0] != 0 && tabptr->ipaddr[1] != 0) if (tabptr->ipaddr != 0)
{ {
/* Check if the source IP address of the incoming packet matches /* Check if the source IP address of the incoming packet matches
* the IP address in this ARP table entry. * the IP address in this ARP table entry.
*/ */
if (pipaddr[0] == tabptr->ipaddr[0] && pipaddr[1] == tabptr->ipaddr[1]) if (uip_ipaddr_cmp(pipaddr, tabptr->ipaddr))
{ {
/* An old entry found, update this and return. */ /* An old entry found, update this and return. */
memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6); memcpy(tabptr->ethaddr.addr, ethaddr->addr, IFHWADDRLEN);
tabptr->time = arptime; tabptr->time = arptime;
return; return;
@ -170,7 +176,7 @@ static void uip_arp_update(uint16 *pipaddr, struct uip_eth_addr *ethaddr)
for (i = 0; i < UIP_ARPTAB_SIZE; ++i) for (i = 0; i < UIP_ARPTAB_SIZE; ++i)
{ {
tabptr = &arp_table[i]; tabptr = &arp_table[i];
if (tabptr->ipaddr[0] == 0 && tabptr->ipaddr[1] == 0) if (tabptr->ipaddr == 0)
{ {
break; break;
} }
@ -201,8 +207,8 @@ static void uip_arp_update(uint16 *pipaddr, struct uip_eth_addr *ethaddr)
* information. * information.
*/ */
memcpy(tabptr->ipaddr, pipaddr, 4); tabptr->ipaddr = pipaddr;
memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6); memcpy(tabptr->ethaddr.addr, ethaddr->addr, IFHWADDRLEN);
tabptr->time = arptime; tabptr->time = arptime;
} }
@ -225,15 +231,11 @@ void uip_arp_ipin(void)
/* Only insert/update an entry if the source IP address of the /* Only insert/update an entry if the source IP address of the
incoming IP packet comes from a host on the local network. */ incoming IP packet comes from a host on the local network. */
if ((IPBUF->srcipaddr[0] & uip_netmask[0]) != (uip_hostaddr[0] & uip_netmask[0])) if ((IPBUF->srcipaddr & dev->d_netmask) != (dev->d_ipaddr & dev->d_netmask))
{ {
return; return;
} }
if ((IPBUF->srcipaddr[1] & uip_netmask[1]) != (uip_hostaddr[1] & uip_netmask[1]))
{
return;
}
uip_arp_update(IPBUF->srcipaddr, &(IPBUF->ethhdr.src)); uip_arp_update(IPBUF->srcipaddr, &(IPBUF->ethhdr.src));
} }
#endif /* 0 */ #endif /* 0 */
@ -273,7 +275,7 @@ void uip_arp_arpin(struct uip_driver_s *dev)
case HTONS(ARP_REQUEST): case HTONS(ARP_REQUEST):
/* ARP request. If it asked for our address, we send out a reply. */ /* ARP request. If it asked for our address, we send out a reply. */
if (uip_ipaddr_cmp(BUF->dipaddr, uip_hostaddr)) if (uip_ipaddr_cmp(BUF->dipaddr, dev->d_ipaddr))
{ {
/* First, we register the one who made the request in our ARP /* First, we register the one who made the request in our ARP
* table, since it is likely that we will do more communication * table, since it is likely that we will do more communication
@ -286,15 +288,13 @@ void uip_arp_arpin(struct uip_driver_s *dev)
BUF->opcode = HTONS(2); BUF->opcode = HTONS(2);
memcpy(BUF->dhwaddr.addr, BUF->shwaddr.addr, 6); memcpy(BUF->dhwaddr.addr, BUF->shwaddr.addr, IFHWADDRLEN);
memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6); memcpy(BUF->shwaddr.addr, dev->d_mac.addr, IFHWADDRLEN);
memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6); memcpy(BUF->ethhdr.src.addr, dev->d_mac.addr, IFHWADDRLEN);
memcpy(BUF->ethhdr.dest.addr, BUF->dhwaddr.addr, 6); memcpy(BUF->ethhdr.dest.addr, BUF->dhwaddr.addr, IFHWADDRLEN);
BUF->dipaddr[0] = BUF->sipaddr[0]; BUF->dipaddr = BUF->sipaddr;
BUF->dipaddr[1] = BUF->sipaddr[1]; BUF->sipaddr = dev->d_ipaddr;
BUF->sipaddr[0] = uip_hostaddr[0];
BUF->sipaddr[1] = uip_hostaddr[1];
BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP); BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
dev->d_len = sizeof(struct arp_hdr); dev->d_len = sizeof(struct arp_hdr);
@ -306,7 +306,7 @@ void uip_arp_arpin(struct uip_driver_s *dev)
* for us. * for us.
*/ */
if (uip_ipaddr_cmp(BUF->dipaddr, uip_hostaddr)) if (uip_ipaddr_cmp(BUF->dipaddr, dev->d_ipaddr))
{ {
uip_arp_update(BUF->sipaddr, &BUF->shwaddr); uip_arp_update(BUF->sipaddr, &BUF->shwaddr);
} }
@ -354,20 +354,20 @@ void uip_arp_out(struct uip_driver_s *dev)
if (uip_ipaddr_cmp(IPBUF->destipaddr, broadcast_ipaddr)) if (uip_ipaddr_cmp(IPBUF->destipaddr, broadcast_ipaddr))
{ {
memcpy(IPBUF->ethhdr.dest.addr, broadcast_ethaddr.addr, 6); memcpy(IPBUF->ethhdr.dest.addr, broadcast_ethaddr.addr, IFHWADDRLEN);
} }
else else
{ {
/* Check if the destination address is on the local network. */ /* Check if the destination address is on the local network. */
if (!uip_ipaddr_maskcmp(IPBUF->destipaddr, uip_hostaddr, uip_netmask)) if (!uip_ipaddr_maskcmp(IPBUF->destipaddr, dev->d_ipaddr, dev->d_netmask))
{ {
/* Destination address was not on the local network, so we need to /* Destination address was not on the local network, so we need to
* use the default router's IP address instead of the destination * use the default router's IP address instead of the destination
* address when determining the MAC address. * address when determining the MAC address.
*/ */
uip_ipaddr_copy(ipaddr, uip_draddr); uip_ipaddr_copy(ipaddr, dev->d_draddr);
} }
else else
{ {
@ -391,17 +391,17 @@ void uip_arp_out(struct uip_driver_s *dev)
* overwrite the IP packet with an ARP request. * overwrite the IP packet with an ARP request.
*/ */
memset(BUF->ethhdr.dest.addr, 0xff, 6); memset(BUF->ethhdr.dest.addr, 0xff, IFHWADDRLEN);
memset(BUF->dhwaddr.addr, 0x00, 6); memset(BUF->dhwaddr.addr, 0x00, IFHWADDRLEN);
memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6); memcpy(BUF->ethhdr.src.addr, dev->d_mac.addr, IFHWADDRLEN);
memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6); memcpy(BUF->shwaddr.addr, dev->d_mac.addr, IFHWADDRLEN);
uip_ipaddr_copy(BUF->dipaddr, ipaddr); uip_ipaddr_copy(BUF->dipaddr, ipaddr);
uip_ipaddr_copy(BUF->sipaddr, uip_hostaddr); uip_ipaddr_copy(BUF->sipaddr, dev->d_ipaddr);
BUF->opcode = HTONS(ARP_REQUEST); /* ARP request. */ BUF->opcode = HTONS(ARP_REQUEST); /* ARP request. */
BUF->hwtype = HTONS(ARP_HWTYPE_ETH); BUF->hwtype = HTONS(ARP_HWTYPE_ETH);
BUF->protocol = HTONS(UIP_ETHTYPE_IP); BUF->protocol = HTONS(UIP_ETHTYPE_IP);
BUF->hwlen = 6; BUF->hwlen = IFHWADDRLEN;
BUF->protolen = 4; BUF->protolen = 4;
BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP); BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
@ -413,9 +413,9 @@ void uip_arp_out(struct uip_driver_s *dev)
/* Build an ethernet header. */ /* Build an ethernet header. */
memcpy(IPBUF->ethhdr.dest.addr, tabptr->ethaddr.addr, 6); memcpy(IPBUF->ethhdr.dest.addr, tabptr->ethaddr.addr, IFHWADDRLEN);
} }
memcpy(IPBUF->ethhdr.src.addr, uip_ethaddr.addr, 6); memcpy(IPBUF->ethhdr.src.addr, dev->d_mac.addr, IFHWADDRLEN);
IPBUF->ethhdr.type = HTONS(UIP_ETHTYPE_IP); IPBUF->ethhdr.type = HTONS(UIP_ETHTYPE_IP);

209
nuttx/net/uip/uip-fw.c
View File

@ -52,44 +52,50 @@ static struct uip_fw_netif *defaultnetif = NULL;
struct tcpip_hdr struct tcpip_hdr
{ {
/* IP header. */ /* IP header */
uint8 vhl,
tos;
uint16 len,
ipid,
ipoffset;
uint8 ttl,
proto;
uint16 ipchksum;
uint16 srcipaddr[2],
destipaddr[2];
/* TCP header. */ uint8 vhl;
uint16 srcport, uint8 tos;
destport; uint16 len;
uint8 seqno[4], uint16 ipid;
ackno[4], uint16 ipoffset;
tcpoffset, uint8 ttl;
flags, uint8 proto;
wnd[2]; uint16 ipchksum;
in_addr_t srcipaddr;
in_addr_t destipaddr;
/* TCP header */
uint16 srcport;
uint16 destport;
uint8 seqno[4];
uint8 ackno[4];
uint8 tcpoffset;
uint8 flags;
uint8 wnd[2];
uint16 tcpchksum; uint16 tcpchksum;
uint8 urgp[2]; uint8 urgp[2];
uint8 optdata[4]; uint8 optdata[4];
}; };
struct icmpip_hdr { struct icmpip_hdr
/* IP header. */ {
uint8 vhl, /* IP header */
tos,
len[2], uint8 vhl;
ipid[2], uint8 tos;
ipoffset[2], uint8 len[2];
ttl, uint8 ipid[2];
proto; uint8 ipoffset[2];
uint8 ttl;
uint8 proto;
uint16 ipchksum; uint16 ipchksum;
uint16 srcipaddr[2], in_addr_t srcipaddr;
destipaddr[2]; in_addr_t destipaddr;
/* ICMP (echo) header. */
/* ICMP (echo) header */
uint8 type, icode; uint8 type, icode;
uint16 icmpchksum; uint16 icmpchksum;
uint16 id, seqno; uint16 id, seqno;
@ -115,8 +121,8 @@ struct icmpip_hdr {
struct fwcache_entry struct fwcache_entry
{ {
uint16 timer; uint16 timer;
uint16 srcipaddr[2]; in_addr_t srcipaddr;
uint16 destipaddr[2]; in_addr_t destipaddr;
uint16 ipid; uint16 ipid;
uint8 proto; uint8 proto;
uint8 unused; uint8 unused;
@ -159,22 +165,6 @@ void uip_fw_init(void)
} }
} }
/* Check if an IP address is within the network defined by an IP
* address and a netmask.
*
* ipaddr The IP address to be checked.
* netipaddr The IP address of the network.
* netmask The netmask of the network.
*
* Return: Non-zero if IP address is in network, zero otherwise.
*/
static unsigned char ipaddr_maskcmp(uint16 *ipaddr, uint16 *netipaddr, uint16 *netmask)
{
return (ipaddr[0] & netmask [0]) == (netipaddr[0] & netmask[0]) &&
(ipaddr[1] & netmask[1]) == (netipaddr[1] & netmask[1]);
}
/* Send out an ICMP TIME-EXCEEDED message. /* Send out an ICMP TIME-EXCEEDED message.
* *
* This function replaces the packet in the d_buf buffer with the * This function replaces the packet in the d_buf buffer with the
@ -183,10 +173,10 @@ static unsigned char ipaddr_maskcmp(uint16 *ipaddr, uint16 *netipaddr, uint16 *n
static void time_exceeded(struct uip_driver_s *dev) static void time_exceeded(struct uip_driver_s *dev)
{ {
uint16 tmp16; in_addr_t tmp_addr;
/* We don't send out ICMP errors for ICMP messages. */ /* We don't send out ICMP errors for ICMP messages. */
if(ICMPBUF->proto == UIP_PROTO_ICMP) { if (ICMPBUF->proto == UIP_PROTO_ICMP) {
dev->d_len = 0; dev->d_len = 0;
return; return;
} }
@ -202,17 +192,16 @@ static void time_exceeded(struct uip_driver_s *dev)
ICMPBUF->icmpchksum = ~uip_chksum((uint16 *)&(ICMPBUF->type), 36); ICMPBUF->icmpchksum = ~uip_chksum((uint16 *)&(ICMPBUF->type), 36);
/* Set the IP destination address to be the source address of the /* Set the IP destination address to be the source address of the
original packet. */ * original packet.
tmp16= BUF->destipaddr[0]; */
BUF->destipaddr[0] = BUF->srcipaddr[0];
BUF->srcipaddr[0] = tmp16; tmp_addr = BUF->destipaddr;
tmp16 = BUF->destipaddr[1]; BUF->destipaddr = BUF->srcipaddr;
BUF->destipaddr[1] = BUF->srcipaddr[1]; BUF->srcipaddr = tmp_addr;
BUF->srcipaddr[1] = tmp16;
/* Set our IP address as the source address. */ /* Set our IP address as the source address. */
BUF->srcipaddr[0] = uip_hostaddr[0];
BUF->srcipaddr[1] = uip_hostaddr[1]; BUF->srcipaddr = dev->d_ipaddr;
/* The size of the ICMP time exceeded packet is 36 + the size of the /* The size of the ICMP time exceeded packet is 36 + the size of the
IP header (20) = 56. */ IP header (20) = 56. */
@ -245,11 +234,11 @@ static void fwcache_register(struct uip_driver_s *dev)
fw = NULL; fw = NULL;
/* Find the oldest entry in the cache. */ /* Find the oldest entry in the cache. */
for(i = 0; i < FWCACHE_SIZE; ++i) { for (i = 0; i < FWCACHE_SIZE; ++i) {
if(fwcache[i].timer == 0) { if (fwcache[i].timer == 0) {
fw = &fwcache[i]; fw = &fwcache[i];
break; break;
} else if(fwcache[i].timer <= oldest) { } else if (fwcache[i].timer <= oldest) {
fw = &fwcache[i]; fw = &fwcache[i];
oldest = fwcache[i].timer; oldest = fwcache[i].timer;
} }
@ -257,10 +246,8 @@ static void fwcache_register(struct uip_driver_s *dev)
fw->timer = FW_TIME; fw->timer = FW_TIME;
fw->ipid = BUF->ipid; fw->ipid = BUF->ipid;
fw->srcipaddr[0] = BUF->srcipaddr[0]; fw->srcipaddr = BUF->srcipaddr;
fw->srcipaddr[1] = BUF->srcipaddr[1]; fw->destipaddr = BUF->destipaddr;
fw->destipaddr[0] = BUF->destipaddr[0];
fw->destipaddr[1] = BUF->destipaddr[1];
fw->proto = BUF->proto; fw->proto = BUF->proto;
#if notdef #if notdef
fw->payload[0] = BUF->srcport; fw->payload[0] = BUF->srcport;
@ -274,20 +261,24 @@ static void fwcache_register(struct uip_driver_s *dev)
/* Find a network interface for the IP packet in d_buf. */ /* Find a network interface for the IP packet in d_buf. */
static struct uip_fw_netif *find_netif(struct uip_driver_s *dev) static struct uip_fw_netif *find_netif (struct uip_driver_s *dev)
{ {
struct uip_fw_netif *netif; struct uip_fw_netif *netif;
/* Walk through every network interface to check for a match. */ /* Walk through every network interface to check for a match. */
for(netif = netifs; netif != NULL; netif = netif->next) {
if(ipaddr_maskcmp(BUF->destipaddr, netif->ipaddr, for (netif = netifs; netif != NULL; netif = netif->next)
netif->netmask)) { {
/* If there was a match, we break the loop. */ if (uip_ipaddr_maskcmp(BUF->destipaddr, netif->ipaddr, netif->netmask))
return netif; {
/* If there was a match, we break the loop. */
return netif;
}
} }
}
/* If no matching netif was found, we use default netif. */ /* If no matching netif was found, we use default netif. */
return defaultnetif; return defaultnetif;
} }
@ -310,7 +301,7 @@ uint8 uip_fw_output(struct uip_driver_s *dev)
{ {
struct uip_fw_netif *netif; struct uip_fw_netif *netif;
if(dev->d_len == 0) { if (dev->d_len == 0) {
return UIP_FW_ZEROLEN; return UIP_FW_ZEROLEN;
} }
@ -318,23 +309,23 @@ uint8 uip_fw_output(struct uip_driver_s *dev)
#if UIP_BROADCAST #if UIP_BROADCAST
/* Link local broadcasts go out on all interfaces. */ /* Link local broadcasts go out on all interfaces. */
if(/*BUF->proto == UIP_PROTO_UDP &&*/ if (/*BUF->proto == UIP_PROTO_UDP &&*/
BUF->destipaddr[0] == 0xffff && BUF->destipaddr[0] == 0xffff &&
BUF->destipaddr[1] == 0xffff) { BUF->destipaddr[1] == 0xffff) {
if(defaultnetif != NULL) { if (defaultnetif != NULL) {
defaultnetif->output(); defaultnetif->output();
} }
for(netif = netifs; netif != NULL; netif = netif->next) { for (netif = netifs; netif != NULL; netif = netif->next) {
netif->output(); netif->output();
} }
return UIP_FW_OK; return UIP_FW_OK;
} }
#endif /* UIP_BROADCAST */ #endif /* UIP_BROADCAST */
netif = find_netif(dev); netif = find_netif (dev);
dbg("uip_fw_output: netif %p ->output %p len %d\n", netif, netif->output, dev->d_len); dbg("uip_fw_output: netif %p ->output %p len %d\n", netif, netif->output, dev->d_len);
if(netif == NULL) { if (netif == NULL) {
return UIP_FW_NOROUTE; return UIP_FW_NOROUTE;
} }
/* If we now have found a suitable network interface, we call its /* If we now have found a suitable network interface, we call its
@ -353,36 +344,35 @@ uint8 uip_fw_forward(struct uip_driver_s *dev)
struct fwcache_entry *fw; struct fwcache_entry *fw;
/* First check if the packet is destined for ourselves and return 0 /* First check if the packet is destined for ourselves and return 0
to indicate that the packet should be processed locally. */ * to indicate that the packet should be processed locally.
if(BUF->destipaddr[0] == uip_hostaddr[0] && */
BUF->destipaddr[1] == uip_hostaddr[1]) {
return UIP_FW_LOCAL; if (BUF->destipaddr == dev->d_ipaddr)
} {
return UIP_FW_LOCAL;
}
/* If we use ping IP address configuration, and our IP address is /* If we use ping IP address configuration, and our IP address is
not yet configured, we should intercept all ICMP echo packets. */ not yet configured, we should intercept all ICMP echo packets. */
#if UIP_PINGADDRCONF #if UIP_PINGADDRCONF
if((uip_hostaddr[0] | uip_hostaddr[1]) == 0 && if (dev->d_ipaddr == 0 && BUF->proto == UIP_PROTO_ICMP && ICMPBUF->type == ICMP_ECHO)
BUF->proto == UIP_PROTO_ICMP && {
ICMPBUF->type == ICMP_ECHO) { return UIP_FW_LOCAL;
return UIP_FW_LOCAL; }
}
#endif /* UIP_PINGADDRCONF */ #endif /* UIP_PINGADDRCONF */
/* Check if the packet is in the forwarding cache already, and if so /* Check if the packet is in the forwarding cache already, and if so
we drop it. */ we drop it. */
for(fw = fwcache; fw < &fwcache[FWCACHE_SIZE]; ++fw) { for (fw = fwcache; fw < &fwcache[FWCACHE_SIZE]; ++fw) {
if(fw->timer != 0 && if (fw->timer != 0 &&
#if UIP_REASSEMBLY > 0 #if UIP_REASSEMBLY > 0
fw->len == BUF->len && fw->len == BUF->len &&
fw->offset == BUF->ipoffset && fw->offset == BUF->ipoffset &&
#endif #endif
fw->ipid == BUF->ipid && fw->ipid == BUF->ipid &&
fw->srcipaddr[0] == BUF->srcipaddr[0] && fw->srcipaddr == BUF->srcipaddr &&
fw->srcipaddr[1] == BUF->srcipaddr[1] && fw->destipaddr == BUF->destipaddr &&
fw->destipaddr[0] == BUF->destipaddr[0] &&
fw->destipaddr[1] == BUF->destipaddr[1] &&
#if notdef #if notdef
fw->payload[0] == BUF->srcport && fw->payload[0] == BUF->srcport &&
fw->payload[1] == BUF->destport && fw->payload[1] == BUF->destport &&
@ -398,31 +388,34 @@ uint8 uip_fw_forward(struct uip_driver_s *dev)
of the packet. of the packet.
*/ */
if(BUF->ttl <= 1) { if (BUF->ttl <= 1)
/* No time exceeded for broadcasts and multicasts! */ {
if(BUF->destipaddr[0] == 0xffff && BUF->destipaddr[1] == 0xffff) { /* No time exceeded for broadcasts and multicasts! */
return UIP_FW_LOCAL;
if (BUF->destipaddr == 0xffffffff)
{
return UIP_FW_LOCAL;
}
time_exceeded(dev);
} }
time_exceeded(dev);
}
/* Decrement the TTL (time-to-live) value in the IP header */ /* Decrement the TTL (time-to-live) value in the IP header */
BUF->ttl = BUF->ttl - 1; BUF->ttl = BUF->ttl - 1;
/* Update the IP checksum. */ /* Update the IP checksum. */
if(BUF->ipchksum >= HTONS(0xffff - 0x0100)) { if (BUF->ipchksum >= HTONS(0xffff - 0x0100)) {
BUF->ipchksum = BUF->ipchksum + HTONS(0x0100) + 1; BUF->ipchksum = BUF->ipchksum + HTONS(0x0100) + 1;
} else { } else {
BUF->ipchksum = BUF->ipchksum + HTONS(0x0100); BUF->ipchksum = BUF->ipchksum + HTONS(0x0100);
} }
if(dev->d_len > 0) { if (dev->d_len > 0) {
dev->d_appdata = &dev->d_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN]; dev->d_appdata = &dev->d_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN];
uip_fw_output(dev); uip_fw_output(dev);
} }
#if UIP_BROADCAST #if UIP_BROADCAST
if(BUF->destipaddr[0] == 0xffff && BUF->destipaddr[1] == 0xffff) { if (BUF->destipaddr[0] == 0xffff && BUF->destipaddr[1] == 0xffff) {
return UIP_FW_LOCAL; return UIP_FW_LOCAL;
} }
#endif /* UIP_BROADCAST */ #endif /* UIP_BROADCAST */
@ -463,8 +456,8 @@ void uip_fw_default(struct uip_fw_netif *netif)
void uip_fw_periodic(void) void uip_fw_periodic(void)
{ {
struct fwcache_entry *fw; struct fwcache_entry *fw;
for(fw = fwcache; fw < &fwcache[FWCACHE_SIZE]; ++fw) { for (fw = fwcache; fw < &fwcache[FWCACHE_SIZE]; ++fw) {
if(fw->timer > 0) { if (fw->timer > 0) {
--fw->timer; --fw->timer;
} }
} }

2
nuttx/net/uip/uip-tcpconn.c
View File

@ -580,7 +580,7 @@ int uip_tcpconnect(struct uip_conn *conn, const struct sockaddr_in *addr)
/* The sockaddr address is 32-bits in network order. */ /* The sockaddr address is 32-bits in network order. */
uip_ipaddr_copy(&conn->ripaddr, addr->sin_addr.s_addr); uip_ipaddr_copy(conn->ripaddr, addr->sin_addr.s_addr);
/* And, finally, put the connection structure into the active /* And, finally, put the connection structure into the active
* list. Because g_active_tcp_connections is accessed from user level and * list. Because g_active_tcp_connections is accessed from user level and

4
nuttx/net/uip/uip-udpconn.c
View File

@ -345,12 +345,12 @@ int uip_udpconnect(struct uip_udp_conn *conn, const struct sockaddr_in *addr)
if (addr) if (addr)
{ {
conn->rport = addr->sin_port; conn->rport = addr->sin_port;
uip_ipaddr_copy(&conn->ripaddr, &addr->sin_addr.s_addr); uip_ipaddr_copy(conn->ripaddr, addr->sin_addr.s_addr);
} }
else else
{ {
conn->rport = 0; conn->rport = 0;
uip_ipaddr_copy(&conn->ripaddr, &all_zeroes_addr); uip_ipaddr_copy(conn->ripaddr, all_zeroes_addr);
} }
conn->ttl = UIP_TTL; conn->ttl = UIP_TTL;
return OK; return OK;

102
nuttx/net/uip/uip.c
View File

@ -74,6 +74,7 @@
#include <nuttx/config.h> #include <nuttx/config.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/ioctl.h>
#include <debug.h> #include <debug.h>
#include <net/uip/uipopt.h> #include <net/uip/uipopt.h>
@ -138,29 +139,6 @@ extern void uip_log(char *msg);
* Public Variables * Public Variables
****************************************************************************/ ****************************************************************************/
/* The IP address of this host. If it is defined to be fixed (by
* setting UIP_FIXEDADDR to 1 in uipopt.h), the address is set
* here.
*/
#if UIP_FIXEDADDR > 0
const uip_ipaddr_t uip_hostaddr =
{HTONS((UIP_IPADDR0 << 8) | UIP_IPADDR1),
HTONS((UIP_IPADDR2 << 8) | UIP_IPADDR3)};
const uip_ipaddr_t uip_draddr =
{HTONS((UIP_DRIPADDR0 << 8) | UIP_DRIPADDR1),
HTONS((UIP_DRIPADDR2 << 8) | UIP_DRIPADDR3)};
const uip_ipaddr_t uip_netmask =
{HTONS((UIP_NETMASK0 << 8) | UIP_NETMASK1),
HTONS((UIP_NETMASK2 << 8) | UIP_NETMASK3)};
#else
uip_ipaddr_t uip_hostaddr;
uip_ipaddr_t uip_draddr;
uip_ipaddr_t uip_netmask;
#endif /* UIP_FIXEDADDR */
#if UIP_URGDATA > 0 #if UIP_URGDATA > 0
void *uip_urgdata; /* The uip_urgdata pointer points to urgent data void *uip_urgdata; /* The uip_urgdata pointer points to urgent data
* (out-of-band data), if present. */ * (out-of-band data), if present. */
@ -168,13 +146,20 @@ uint16 uip_urglen;
uint16 uip_surglen; uint16 uip_surglen;
#endif /* UIP_URGDATA > 0 */ #endif /* UIP_URGDATA > 0 */
uint8 uip_flags; /* The uip_flags variable is used for communication /* The uip_flags variable is used for communication between the TCP/IP
* between the TCP/IP stack and the application * stack and the application program.
* program. */ */
struct uip_conn *uip_conn; /* uip_conn always points to the current connection. */
uint8 uip_flags;
/* uip_conn always points to the current connection. */
struct uip_conn *uip_conn;
/* The uip_listenports list all currently listening ports. */
uint16 uip_listenports[UIP_LISTENPORTS]; uint16 uip_listenports[UIP_LISTENPORTS];
/* The uip_listenports list all currently listening ports. */
#ifdef CONFIG_NET_UDP #ifdef CONFIG_NET_UDP
struct uip_udp_conn *uip_udp_conn; struct uip_udp_conn *uip_udp_conn;
#endif /* CONFIG_NET_UDP */ #endif /* CONFIG_NET_UDP */
@ -194,27 +179,20 @@ const uip_ipaddr_t all_ones_addr =
#ifdef CONFIG_NET_IPv6 #ifdef CONFIG_NET_IPv6
{0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff}; {0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff};
#else /* CONFIG_NET_IPv6 */ #else /* CONFIG_NET_IPv6 */
{0xffff,0xffff}; {0xffffffff};
#endif /* CONFIG_NET_IPv6 */ #endif /* CONFIG_NET_IPv6 */
const uip_ipaddr_t all_zeroes_addr = const uip_ipaddr_t all_zeroes_addr =
#ifdef CONFIG_NET_IPv6 #ifdef CONFIG_NET_IPv6
{0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000}; {0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000};
#else /* CONFIG_NET_IPv6 */ #else /* CONFIG_NET_IPv6 */
{0x0000,0x0000}; {0x00000000};
#endif /* CONFIG_NET_IPv6 */ #endif /* CONFIG_NET_IPv6 */
/**************************************************************************** /****************************************************************************
* Private Variables * Private Variables
****************************************************************************/ ****************************************************************************/
#if UIP_FIXEDETHADDR
const struct uip_eth_addr uip_ethaddr =
{{ UIP_ETHADDR0, UIP_ETHADDR1, UIP_ETHADDR2, UIP_ETHADDR3, UIP_ETHADDR4, UIP_ETHADDR5 }};
#else
struct uip_eth_addr uip_ethaddr = {{ 0,0,0,0,0,0 }};
#endif
static uint16 ipid; /* Ths ipid variable is an increasing number that is static uint16 ipid; /* Ths ipid variable is an increasing number that is
* used for the IP ID field. */ * used for the IP ID field. */
@ -283,7 +261,7 @@ static uint16 upper_layer_chksum(struct uip_driver_s *dev, uint8 proto)
sum = upper_layer_len + proto; sum = upper_layer_len + proto;
/* Sum IP source and destination addresses. */ /* Sum IP source and destination addresses. */
sum = chksum(sum, (uint8 *)&BUF->srcipaddr[0], 2 * sizeof(uip_ipaddr_t)); sum = chksum(sum, (uint8 *)&BUF->srcipaddr, 2 * sizeof(uip_ipaddr_t));
/* Sum TCP header and data. */ /* Sum TCP header and data. */
sum = chksum(sum, &dev->d_buf[UIP_IPH_LEN + UIP_LLH_LEN], upper_layer_len); sum = chksum(sum, &dev->d_buf[UIP_IPH_LEN + UIP_LLH_LEN], upper_layer_len);
@ -397,9 +375,6 @@ void uip_init(void)
uip_udpinit(); uip_udpinit();
/* IPv4 initialization. */ /* IPv4 initialization. */
#if UIP_FIXEDADDR == 0
/* uip_hostaddr[0] = uip_hostaddr[1] = 0;*/
#endif /* UIP_FIXEDADDR */
} }
void uip_unlisten(uint16 port) void uip_unlisten(uint16 port)
@ -465,8 +440,8 @@ static uint8 uip_reass(void)
* fragment into the buffer. * fragment into the buffer.
*/ */
if (BUF->srcipaddr[0] == FBUF->srcipaddr[0] && BUF->srcipaddr[1] == FBUF->srcipaddr[1] && if (uip_addr_cmp(BUF->srcipaddr, FBUF->srcipaddr) &&
BUF->destipaddr[0] == FBUF->destipaddr[0] && BUF->destipaddr[1] == FBUF->destipaddr[1] && uip_addr_cmp(BUF->destipaddr == FBUF->destipaddr) &&
BUF->ipid[0] == FBUF->ipid[0] && BUF->ipid[1] == FBUF->ipid[1]) BUF->ipid[0] == FBUF->ipid[0] && BUF->ipid[1] == FBUF->ipid[1])
{ {
len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4; len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
@ -879,7 +854,7 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 flag)
} }
#endif /* CONFIG_NET_IPv6 */ #endif /* CONFIG_NET_IPv6 */
if (uip_ipaddr_cmp(uip_hostaddr, all_zeroes_addr)) if (uip_ipaddr_cmp(dev->d_ipaddr, all_zeroes_addr))
{ {
/* If we are configured to use ping IP address configuration and /* If we are configured to use ping IP address configuration and
hasn't been assigned an IP address yet, we accept all ICMP hasn't been assigned an IP address yet, we accept all ICMP
@ -914,19 +889,21 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 flag)
/* Check if the packet is destined for our IP address. */ /* Check if the packet is destined for our IP address. */
#ifndef CONFIG_NET_IPv6 #ifndef CONFIG_NET_IPv6
if (!uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr)) if (!uip_ipaddr_cmp(BUF->destipaddr, dev->d_ipaddr))
{ {
UIP_STAT(++uip_stat.ip.drop); UIP_STAT(++uip_stat.ip.drop);
goto drop; goto drop;
} }
#else /* CONFIG_NET_IPv6 */ #else /* CONFIG_NET_IPv6 */
/* For IPv6, packet reception is a little trickier as we need to /* For IPv6, packet reception is a little trickier as we need to
make sure that we listen to certain multicast addresses (all * make sure that we listen to certain multicast addresses (all
hosts multicast address, and the solicited-node multicast * hosts multicast address, and the solicited-node multicast
address) as well. However, we will cheat here and accept all * address) as well. However, we will cheat here and accept all
multicast packets that are sent to the ff02::/16 addresses. */ * multicast packets that are sent to the ff02::/16 addresses.
if (!uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr) && */
BUF->destipaddr[0] != HTONS(0xff02))
if (!uip_ipaddr_cmp(BUF->destipaddr, dev->d_ipaddr) &&
BUF->destipaddr & HTONL(0xffff0000) != HTONL(0xff020000))
{ {
UIP_STAT(++uip_stat.ip.drop); UIP_STAT(++uip_stat.ip.drop);
goto drop; goto drop;
@ -992,10 +969,9 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 flag)
the destination IP address of this ping packet and assign it to the destination IP address of this ping packet and assign it to
ourself. */ ourself. */
#if UIP_PINGADDRCONF #if UIP_PINGADDRCONF
if ((uip_hostaddr[0] | uip_hostaddr[1]) == 0) if (dev->d_ipaddr == 0)
{ {
uip_hostaddr[0] = BUF->destipaddr[0]; dev->d_ipaddr = BUF->destipaddr;
uip_hostaddr[1] = BUF->destipaddr[1];
} }
#endif /* UIP_PINGADDRCONF */ #endif /* UIP_PINGADDRCONF */
@ -1013,7 +989,7 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 flag)
/* Swap IP addresses. */ /* Swap IP addresses. */
uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr); uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr); uip_ipaddr_copy(BUF->srcipaddr, dev->d_ipaddr);
UIP_STAT(++uip_stat.icmp.sent); UIP_STAT(++uip_stat.icmp.sent);
goto send; goto send;
@ -1040,7 +1016,7 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 flag)
a neighbor advertisement message back. */ a neighbor advertisement message back. */
if (ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION) if (ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION)
{ {
if (uip_ipaddr_cmp(ICMPBUF->icmp6data, uip_hostaddr)) if (uip_ipaddr_cmp(ICMPBUF->icmp6data, dev->d_ipaddr))
{ {
if (ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS) if (ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS)
{ {
@ -1056,10 +1032,10 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 flag)
ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0; ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0;
uip_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr); uip_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr);
uip_ipaddr_copy(ICMPBUF->srcipaddr, uip_hostaddr); uip_ipaddr_copy(ICMPBUF->srcipaddr, dev->d_ipaddr);
ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS; ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;
ICMPBUF->options[1] = 1; /* Options length, 1 = 8 bytes. */ ICMPBUF->options[1] = 1; /* Options length, 1 = 8 bytes. */
memcpy(&(ICMPBUF->options[2]), &uip_ethaddr, sizeof(uip_ethaddr)); memcpy(&(ICMPBUF->options[2]), &dev->d_mac, IFHWADDRLEN);
ICMPBUF->icmpchksum = 0; ICMPBUF->icmpchksum = 0;
ICMPBUF->icmpchksum = ~uip_icmp6chksum(dev); ICMPBUF->icmpchksum = ~uip_icmp6chksum(dev);
goto send; goto send;
@ -1075,7 +1051,7 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 flag)
ICMPBUF->type = ICMP6_ECHO_REPLY; ICMPBUF->type = ICMP6_ECHO_REPLY;
uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr); uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr); uip_ipaddr_copy(BUF->srcipaddr, dev->d_ipaddr);
ICMPBUF->icmpchksum = 0; ICMPBUF->icmpchksum = 0;
ICMPBUF->icmpchksum = ~uip_icmp6chksum(dev); ICMPBUF->icmpchksum = ~uip_icmp6chksum(dev);
@ -1160,7 +1136,7 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 flag)
BUF->srcport = uip_udp_conn->lport; BUF->srcport = uip_udp_conn->lport;
BUF->destport = uip_udp_conn->rport; BUF->destport = uip_udp_conn->rport;
uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr); uip_ipaddr_copy(BUF->srcipaddr, dev->d_ipaddr);
uip_ipaddr_copy(BUF->destipaddr, uip_udp_conn->ripaddr); uip_ipaddr_copy(BUF->destipaddr, uip_udp_conn->ripaddr);
dev->d_appdata = &dev->d_buf[UIP_LLH_LEN + UIP_IPTCPH_LEN]; dev->d_appdata = &dev->d_buf[UIP_LLH_LEN + UIP_IPTCPH_LEN];
@ -1275,7 +1251,7 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 flag)
/* Swap IP addresses. */ /* Swap IP addresses. */
uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr); uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr); uip_ipaddr_copy(BUF->srcipaddr, dev->d_ipaddr);
/* And send out the RST packet! */ /* And send out the RST packet! */
goto tcp_send_noconn; goto tcp_send_noconn;
@ -1875,7 +1851,7 @@ tcp_send_synack:
BUF->srcport = uip_connr->lport; BUF->srcport = uip_connr->lport;
BUF->destport = uip_connr->rport; BUF->destport = uip_connr->rport;
uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr); uip_ipaddr_copy(BUF->srcipaddr, dev->d_ipaddr);
uip_ipaddr_copy(BUF->destipaddr, uip_connr->ripaddr); uip_ipaddr_copy(BUF->destipaddr, uip_connr->ripaddr);
if (uip_connr->tcpstateflags & UIP_STOPPED) if (uip_connr->tcpstateflags & UIP_STOPPED)

8
nuttx/netutils/dhcpc/dhcpc.c
View File

@ -182,6 +182,8 @@ static uint8 *add_end(uint8 *optptr)
static void create_msg(struct dhcpc_state_internal *pdhcpc, struct dhcp_msg *pmsg) static void create_msg(struct dhcpc_state_internal *pdhcpc, struct dhcp_msg *pmsg)
{ {
struct in_addr addr;
pmsg->op = DHCP_REQUEST; pmsg->op = DHCP_REQUEST;
pmsg->htype = DHCP_HTYPE_ETHERNET; pmsg->htype = DHCP_HTYPE_ETHERNET;
pmsg->hlen = pdhcpc->mac_len; pmsg->hlen = pdhcpc->mac_len;
@ -189,11 +191,13 @@ static void create_msg(struct dhcpc_state_internal *pdhcpc, struct dhcp_msg *pms
memcpy(pmsg->xid, xid, sizeof(pmsg->xid)); memcpy(pmsg->xid, xid, sizeof(pmsg->xid));
pmsg->secs = 0; pmsg->secs = 0;
pmsg->flags = HTONS(BOOTP_BROADCAST); /* Broadcast bit. */ pmsg->flags = HTONS(BOOTP_BROADCAST); /* Broadcast bit. */
/* uip_ipaddr_copy(pmsg->ciaddr, uip_hostaddr);*/
memcpy(pmsg->ciaddr, uip_hostaddr, sizeof(pmsg->ciaddr)); uip_gethostaddr( "eth0", &addr);
memcpy(&pmsg->ciaddr, &addr.s_addr, sizeof(pmsg->ciaddr));
memset(pmsg->yiaddr, 0, sizeof(pmsg->yiaddr)); memset(pmsg->yiaddr, 0, sizeof(pmsg->yiaddr));
memset(pmsg->siaddr, 0, sizeof(pmsg->siaddr)); memset(pmsg->siaddr, 0, sizeof(pmsg->siaddr));
memset(pmsg->giaddr, 0, sizeof(pmsg->giaddr)); memset(pmsg->giaddr, 0, sizeof(pmsg->giaddr));
memcpy(pmsg->chaddr, pdhcpc->mac_addr, pdhcpc->mac_len); memcpy(pmsg->chaddr, pdhcpc->mac_addr, pdhcpc->mac_len);
memset(&pmsg->chaddr[pdhcpc->mac_len], 0, sizeof(pmsg->chaddr) - pdhcpc->mac_len); memset(&pmsg->chaddr[pdhcpc->mac_len], 0, sizeof(pmsg->chaddr) - pdhcpc->mac_len);
#ifndef CONFIG_NET_DHCP_LIGHT #ifndef CONFIG_NET_DHCP_LIGHT

2
nuttx/netutils/uiplib/Make.defs
View File

@ -34,4 +34,4 @@
############################################################################ ############################################################################
UIPLIB_ASRCS = UIPLIB_ASRCS =
UIPLIB_CSRCS = uiplib.c UIPLIB_CSRCS = uiplib.c uip-sethostaddr.c uip-gethostaddr.c uip-setdraddr.c uip-setnetmask.c

93
nuttx/netutils/uiplib/uip-gethostaddr.c Normal file
View File

@ -0,0 +1,93 @@
/****************************************************************************
* netutils/uiplib/uip-gethostaddr.c
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#if defined(CONFIG_NET) && CONFIG_NSOCKET_DESCRIPTORS > 0
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
/****************************************************************************
* Global Functions
****************************************************************************/
/****************************************************************************
* Name: uip_sethostaddr
*
* Description:
* Get the network driver IP address
*
* Parameters:
* ifname The name of the interface to use
* ipaddr The address to set
*
* Return:
* 0 on sucess; -1 on failure
*
****************************************************************************/
#ifdef CONFIG_NET_IPv6
int uip_gethostaddr(const char *ifname, struct in6_addr *addr)
#else
int uip_gethostaddr(const char *ifname, struct in_addr *addr)
#endif
{
int ret = ERROR;
if (ifname && addr)
{
int sockfd = socket(PF_INET, SOCK_DGRAM, 0);
if (sockfd >= 0)
{
struct ifreq req;
strncpy(req.ifr_name, ifname, IFNAMSIZ);
ret = ioctl(sockfd, SIOCSIFADDR, (unsigned long)&req);
if (!ret)
{
memcpy(addr, &req.ifr_addr, sizeof(addr));
}
}
}
return ret;
}
#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

89
nuttx/netutils/uiplib/uip-setdraddr.c Normal file
View File

@ -0,0 +1,89 @@
/****************************************************************************
* netutils/uiplib/uip-setdraddr.c
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#if defined(CONFIG_NET) && CONFIG_NSOCKET_DESCRIPTORS > 0
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
/****************************************************************************
* Global Functions
****************************************************************************/
/****************************************************************************
* Name: uip_setdraddr
*
* Description:
* Set the default router IP address
*
* Parameters:
* ifname The name of the interface to use
* ipaddr The address to set
*
* Return:
* 0 on sucess; -1 on failure
*
****************************************************************************/
#ifdef CONFIG_NET_IPv6
int uip_setdraddr(const char *ifname, const struct in6_addr *addr)
#else
int uip_setdraddr(const char *ifname, const struct in_addr *addr)
#endif
{
if (ifname && addr)
{
int sockfd = socket(PF_INET, SOCK_DGRAM, 0);
if (sockfd >= 0)
{
struct ifreq req;
strncpy(req.ifr_name, ifname, IFNAMSIZ);
memcpy(&req.ifr_addr, addr, sizeof(addr));
return ioctl(sockfd, SIOCSIFDSTADDR, (unsigned long)&req);
}
}
return ERROR;
}
#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

89
nuttx/netutils/uiplib/uip-sethostaddr.c Normal file
View File

@ -0,0 +1,89 @@
/****************************************************************************
* netutils/uiplib/uip-sethostaddr.c
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#if defined(CONFIG_NET) && CONFIG_NSOCKET_DESCRIPTORS > 0
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
/****************************************************************************
* Global Functions
****************************************************************************/
/****************************************************************************
* Name: uip_sethostaddr
*
* Description:
* Set the network driver IP address
*
* Parameters:
* ifname The name of the interface to use
* ipaddr The address to set
*
* Return:
* 0 on sucess; -1 on failure
*
****************************************************************************/
#ifdef CONFIG_NET_IPv6
int uip_sethostaddr(const char *ifname, const struct in6_addr *addr)
#else
int uip_sethostaddr(const char *ifname, const struct in_addr *addr)
#endif
{
if (ifname && addr)
{
int sockfd = socket(PF_INET, SOCK_DGRAM, 0);
if (sockfd >= 0)
{
struct ifreq req;
strncpy(req.ifr_name, ifname, IFNAMSIZ);
memcpy(&req.ifr_addr, addr, sizeof(addr));
return ioctl(sockfd, SIOCSIFADDR, (unsigned long)&req);
}
}
return ERROR;
}
#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

89
nuttx/netutils/uiplib/uip-setnetmask.c Normal file
View File

@ -0,0 +1,89 @@
/****************************************************************************
* netutils/uiplib/uip-setnetmask.c
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#if defined(CONFIG_NET) && CONFIG_NSOCKET_DESCRIPTORS > 0
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
/****************************************************************************
* Global Functions
****************************************************************************/
/****************************************************************************
* Name: uip_setnetmask
*
* Description:
* Set the netmask
*
* Parameters:
* ifname The name of the interface to use
* ipaddr The address to set
*
* Return:
* 0 on sucess; -1 on failure
*
****************************************************************************/
#ifdef CONFIG_NET_IPv6
int uip_setnetmask(const char *ifname, const struct in6_addr *addr)
#else
int uip_setnetmask(const char *ifname, const struct in_addr *addr)
#endif
{
if (ifname && addr)
{
int sockfd = socket(PF_INET, SOCK_DGRAM, 0);
if (sockfd >= 0)
{
struct ifreq req;
strncpy(req.ifr_name, ifname, IFNAMSIZ);
memcpy(&req.ifr_addr, addr, sizeof(addr));
return ioctl(sockfd, SIOCGIFNETMASK, (unsigned long)&req);
}
}
return ERROR;
}
#endif /* CONFIG_NET && CONFIG_NSOCKET_DESCRIPTORS */

11
nuttx/netutils/uiplib/uiplib.h
View File

@ -42,6 +42,8 @@
#ifndef __UIPLIB_H__ #ifndef __UIPLIB_H__
#define __UIPLIB_H__ #define __UIPLIB_H__
#include <netinet/in.h>
/* Convert a textual representation of an IP address to a numerical representation. /* Convert a textual representation of an IP address to a numerical representation.
* *
* This function takes a textual representation of an IP address in * This function takes a textual representation of an IP address in
@ -58,6 +60,13 @@
* Return: Non-zero If the IP address was parsed. * Return: Non-zero If the IP address was parsed.
*/ */
unsigned char uiplib_ipaddrconv(char *addrstr, unsigned char *addr); extern unsigned char uiplib_ipaddrconv(char *addrstr, unsigned char *addr);
/* Get and set IP addresses */
extern int uip_gethostaddr(const char *ifname, struct in6_addr *addr);
extern int uip_sethostaddr(const char *ifname, const struct in6_addr *addr);
extern int uip_setdraddr(const char *ifname, const struct in6_addr *addr);
extern int uip_setnetmask(const char *ifname, const struct in6_addr *addr);
#endif /* __UIPLIB_H__ */ #endif /* __UIPLIB_H__ */