libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'china/master'

This commit is contained in:
Bernard Xiong 2015-01-31 12:58:24 +00:00
parent 92e0f0d452 622e6d8238
commit 390973a755
14 changed files with 848 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
components/libc/dlib/README.md Normal file
View File

@ -0,0 +1,4 @@
Dlib(IAR) porting for RT-Thread.
Please define RT_USING_LIBC and compile RT-Thread with IAR compiler.

15
components/libc/dlib/SConscript Normal file
View File

@ -0,0 +1,15 @@
from building import *
import rtconfig
src = Glob('*.c')
cwd = GetCurrentDir()
group = []
CPPPATH = [cwd]
CPPDEFINES = ['RT_USING_DLIBC']
if rtconfig.PLATFORM == 'iar':
group = DefineGroup('dlib', src, depend = ['RT_USING_LIBC'],
CPPPATH = CPPPATH, CPPDEFINES = CPPDEFINES, LIBS = LIBS)
Return('group')

25
components/libc/dlib/environ.c Normal file
View File

@ -0,0 +1,25 @@
/* File: environ.c
* this file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2015, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2015-01-28 Bernard first version
*/
const char *__environ = "OS=RT-Thread";

73
components/libc/dlib/rmtx.c Normal file
View File

@ -0,0 +1,73 @@
/*
* File : rmtx.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2015, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2015-01-28 Bernard first version
*/
#include <rtthread.h>
#include <yfuns.h>
/*
* for IAR compiler, we recommand to define _DLIB_THREAD_SUPPORT
* as 2 for dlib multi-thread support.
*/
#if _DLIB_THREAD_SUPPORT
void _Mtxinit(_Rmtx *m)
{
rt_mutex_t mutex;
RT_ASSERT(m != RT_NULL);
mutex = (rt_mutex_t)m;
rt_mutex_init(mutex, "iarMtx", RT_IPC_FLAG_FIFO);
}
void _Mtxdst(_Rmtx *m)
{
rt_mutex_t mutex;
RT_ASSERT(m != RT_NULL);
mutex = (rt_mutex_t)m;
rt_mutex_detach(mutex);
}
void _Mtxlock(_Rmtx *m)
{
rt_mutex_t mutex;
RT_ASSERT(m != RT_NULL);
mutex = (rt_mutex_t)m;
rt_mutex_take(mutex, RT_WAITING_FOREVER);
}
void _Mtxunlock(_Rmtx *m)
{
rt_mutex_t mutex;
RT_ASSERT(m != RT_NULL);
mutex = (rt_mutex_t)m;
rt_mutex_release(mutex);
}
#endif

64
components/libc/dlib/syscall_open.c Normal file
View File

@ -0,0 +1,64 @@
/*
* File : syscall_open.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2015, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2015-01-28 Bernard first version
*/
#include <rtthread.h>
#include <yfuns.h>
#ifdef RT_USING_DFS
#include <dfs_posix.h>
#endif
#pragma module_name = "?__open"
int __open(const char *filename, int mode)
{
if (mode & _LLIO_CREAT)
{
}
if (mode & _LLIO_TEXT)
{
/* we didn't support text mode */
}
switch (mode & _LLIO_RDWRMASK)
{
case _LLIO_RDONLY:
/* The file should be opened for read only. */
break;
case _LLIO_WRONLY:
/* The file should be opened for write only. */
break;
case _LLIO_RDWR:
/* The file should be opened for both reads and writes. */
break;
default:
return -1;
}
return handle;
}

51
components/libc/dlib/syscall_read.c Normal file
View File

@ -0,0 +1,51 @@
/*
* File : syscall_read.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2015, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2015-01-28 Bernard first version
*/
#include <rtthread.h>
#include <yfuns.h>
#pragma module_name = "?__read"
size_t __read(int handle, unsigned char *buf, size_t len)
{
#ifdef RT_USING_DFS
int size;
#endif
if (handle == _LLIO_STDIN)
{
/* TODO */
return 0;
}
if ((handle == _LLIO_STDOUT) || (handle == _LLIO_STDERR))
return _LLIO_ERROR;
#ifndef RT_USING_DFS
return _LLIO_ERROR;
#else
size = read(handle - STDERR - 1, buf, len);
return size;
#endif
}

59
components/libc/dlib/syscall_write.c Normal file
View File

@ -0,0 +1,59 @@
/*
* File : syscall_write.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2015, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2015-01-28 Bernard first version
*/
#include <rtthread.h>
#include <yfuns.h>
#pragma module_name = "?__write"
size_t __write(int handle, const unsigned char *buf, size_t len)
{
#ifdef RT_USING_DFS
int size;
#endif
if ((handle == _LLIO_STDOUT) || (handle == _LLIO_STDERR))
{
#ifndef RT_USING_CONSOLE
return _LLIO_ERROR;
#else
rt_device_t console_device;
console_device = rt_console_get_device();
if (console_device != 0) rt_device_write(console_device, 0, buf, len);
return len;
#endif
}
if (handle == STDIN) return -1;
#ifndef RT_USING_DFS
return _LLIO_ERROR;
#else
size = write(handle - STDERR - 1, buf, len);
return size;
#endif
}

68
components/libc/dlib/syscalls.c Normal file
View File

@ -0,0 +1,68 @@
/*
* File : syscalls.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2015, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2015-01-28 Bernard first version
*/
#include <rtthread.h>
#ifdef RT_USING_DFS
#include <dfs_file.h>
#endif
#include <yfuns.h>
#pragma module_name = "?__close"
int __close(int handle)
{
if (handle == _LLIO_STDOUT ||
handle == _LLIO_STDERR ||
handle == _LLIO_STDIN)
return _LLIO_ERROR;
#ifdef RT_USING_DFS
return close(handle);
#else
return 0;
#endif
}
#pragma module_name = "?remove"
int remove(const char *val)
{
#ifdef RT_USING_DFS
dfs_file_unlink(val);
#endif
return 0;
}
#pragma module_name = "?__lseek"
long __lseek(int handle, long offset, int whence)
{
#ifdef RT_USING_DFS
#endif
if (handle == _LLIO_STDOUT ||
handle == _LLIO_STDERR ||
handle == _LLIO_STDIN)
return _LLIO_ERROR;
return lseek(handle, offset, whence);
}

23
components/libc/dlib/syscalls.h Normal file
View File

@ -0,0 +1,23 @@
/* File: syscalls.h
* this file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2015, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2015-01-28 Bernard first version
*/

4
components/net/lwip-1.4.1/src/lwipopts.h
View File

@ -162,9 +162,9 @@
#define SYS_LIGHTWEIGHT_PROT (NO_SYS==0) #define SYS_LIGHTWEIGHT_PROT (NO_SYS==0)
#ifdef LWIP_USING_NAT #ifdef LWIP_USING_NAT
#define LWIP_NAT 1 #define IP_NAT 1
#else #else
#define LWIP_NAT 0 #define IP_NAT 0
#endif #endif
/* ---------- TCP options ---------- */ /* ---------- TCP options ---------- */

10
components/net/lwip_dhcpd/SConscript Normal file
View File

@ -0,0 +1,10 @@
from building import *
cwd = GetCurrentDir()
src = Glob('*.c')
CPPPATH = [cwd]
group = DefineGroup('LwIP', src, depend = ['RT_USING_LWIP', 'LWIP_USING_DHCPD'], CPPPATH = CPPPATH)
Return('group')

398
components/net/lwip_dhcpd/dhcp_server.c Normal file
View File

@ -0,0 +1,398 @@
/*
* File : dhcp_server.c
* A simple DHCP server implementation
*
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2013-2015, Shanghai Real-Thread Technology Co., Ltd
* http://www.rt-thread.com
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2013-01-30 aozima the first version
* 2013-08-08 aozima support different network segments.
* 2015-01-30 bernard release to RT-Thread RTOS.
*/
#include <stdio.h>
#include <stdint.h>
#include <rtthread.h>
#include <lwip/opt.h>
#include <lwip/sockets.h>
#include <lwip/inet_chksum.h>
#include <netif/etharp.h>
#include <netif/ethernetif.h>
#include <lwip/ip.h>
/* DHCP server option */
/* allocated client ip range */
#ifndef DHCPD_CLIENT_IP_MIN
#define DHCPD_CLIENT_IP_MIN 2
#endif
#ifndef DHCPD_CLIENT_IP_MAX
#define DHCPD_CLIENT_IP_MAX 254
#endif
/* the DHCP server address */
#ifndef DHCPD_SERVER_IPADDR0
#define DHCPD_SERVER_IPADDR0 192UL
#define DHCPD_SERVER_IPADDR1 168UL
#define DHCPD_SERVER_IPADDR2 169UL
#define DHCPD_SERVER_IPADDR3 1UL
#endif
//#define DHCP_DEBUG_PRINTF
#ifdef DHCP_DEBUG_PRINTF
#define DEBUG_PRINTF rt_kprintf("[DHCP] "); rt_kprintf
#else
#define DEBUG_PRINTF(...)
#endif /* DHCP_DEBUG_PRINTF */
/* we need some routines in the DHCP of lwIP */
#undef LWIP_DHCP
#define LWIP_DHCP 1
#include <lwip/dhcp.h>
/* buffer size for receive DHCP packet */
#define BUFSZ 1024
static uint8_t next_client_ip = DHCPD_CLIENT_IP_MIN;
static rt_err_t _low_level_dhcp_send(struct netif *netif,
const void *buffer,
rt_size_t size)
{
struct pbuf *p;
struct eth_hdr *ethhdr;
struct ip_hdr *iphdr;
struct udp_hdr *udphdr;
p = pbuf_alloc(PBUF_LINK,
SIZEOF_ETH_HDR + sizeof(struct ip_hdr)
+ sizeof(struct udp_hdr) + size,
PBUF_RAM);
if (p == RT_NULL) return -RT_ENOMEM;
ethhdr = (struct eth_hdr *)p->payload;
iphdr = (struct ip_hdr *)((char *)ethhdr + SIZEOF_ETH_HDR);
udphdr = (struct udp_hdr *)((char *)iphdr + sizeof(struct ip_hdr));
ETHADDR32_COPY(&ethhdr->dest, (struct eth_addr *)&ethbroadcast);
ETHADDR16_COPY(&ethhdr->src, netif->hwaddr);
ethhdr->type = PP_HTONS(ETHTYPE_IP);
iphdr->src.addr = 0x00000000; /* src: 0.0.0.0 */
iphdr->dest.addr = 0xFFFFFFFF; /* src: 255.255.255.255 */
IPH_VHL_SET(iphdr, 4, IP_HLEN / 4);
IPH_TOS_SET(iphdr, 0x00);
IPH_LEN_SET(iphdr, htons(IP_HLEN + sizeof(struct udp_hdr) + size));
IPH_ID_SET(iphdr, htons(2));
IPH_OFFSET_SET(iphdr, 0);
IPH_TTL_SET(iphdr, 255);
IPH_PROTO_SET(iphdr, IP_PROTO_UDP);
IPH_CHKSUM_SET(iphdr, 0);
IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN));
udphdr->src = htons(DHCP_SERVER_PORT);
udphdr->dest = htons(DHCP_CLIENT_PORT);
udphdr->len = htons(sizeof(struct udp_hdr) + size);
udphdr->chksum = 0;
memcpy((char *)udphdr + sizeof(struct udp_hdr),
buffer, size);
return netif->linkoutput(netif, p);
}
static void dhcpd_thread_entry(void *parameter)
{
struct netif *netif = RT_NULL;
int sock;
int bytes_read;
char *recv_data;
rt_uint32_t addr_len;
struct sockaddr_in server_addr, client_addr;
struct dhcp_msg *msg;
int optval = 1;
/* get ethernet interface. */
netif = (struct netif*) parameter;
RT_ASSERT(netif != RT_NULL);
/* our DHCP server information */
DEBUG_PRINTF("DHCP server IP: %d.%d.%d.%d client IP: %d.%d.%d.%d-%d\n",
DHCPD_SERVER_IPADDR0, DHCPD_SERVER_IPADDR1,
DHCPD_SERVER_IPADDR2, DHCPD_SERVER_IPADDR3,
DHCPD_SERVER_IPADDR0, DHCPD_SERVER_IPADDR1,
DHCPD_SERVER_IPADDR2, DHCPD_CLIENT_IP_MIN, DHCPD_CLIENT_IP_MAX);
/* allocate buffer for receive */
recv_data = rt_malloc(BUFSZ);
if (recv_data == RT_NULL)
{
/* No memory */
DEBUG_PRINTF("Out of memory\n");
return;
}
/* create a socket with UDP */
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
DEBUG_PRINTF("create socket failed, errno = %d\n", errno);
rt_free(recv_data);
return;
}
/* set to receive broadcast packet */
setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &optval, sizeof(optval));
/* initialize server address */
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(DHCP_SERVER_PORT);
server_addr.sin_addr.s_addr = INADDR_ANY;
rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
/* bind socket to the server address */
if (bind(sock, (struct sockaddr *)&server_addr,
sizeof(struct sockaddr)) == -1)
{
/* bind failed. */
DEBUG_PRINTF("bind server address failed, errno=%d\n", errno);
rt_free(recv_data);
return;
}
addr_len = sizeof(struct sockaddr);
DEBUG_PRINTF("DHCP server listen on port %d...\n", DHCP_SERVER_PORT);
while (1)
{
bytes_read = recvfrom(sock, recv_data, BUFSZ - 1, 0,
(struct sockaddr *)&client_addr, &addr_len);
if (bytes_read < DHCP_MSG_LEN)
{
DEBUG_PRINTF("packet too short, wait for next!\n");
continue;
}
msg = (struct dhcp_msg *)recv_data;
/* check message type to make sure we can handle it */
if ((msg->op != DHCP_BOOTREQUEST) || (msg->cookie != PP_HTONL(DHCP_MAGIC_COOKIE)))
{
continue;
}
/* handler. */
{
uint8_t *dhcp_opt;
uint8_t option;
uint8_t length;
uint8_t message_type = 0;
uint8_t finished = 0;
uint32_t request_ip = 0;
dhcp_opt = (uint8_t *)msg + DHCP_OPTIONS_OFS;
while (finished == 0)
{
option = *dhcp_opt;
length = *(dhcp_opt + 1);
switch (option)
{
case DHCP_OPTION_REQUESTED_IP:
request_ip = *(dhcp_opt + 2) << 24 | *(dhcp_opt + 3) << 16
| *(dhcp_opt + 4) << 8 | *(dhcp_opt + 5);
break;
case DHCP_OPTION_END:
finished = 1;
break;
case DHCP_OPTION_MESSAGE_TYPE:
message_type = *(dhcp_opt + 2);
break;
default:
break;
} /* switch(option) */
dhcp_opt += (2 + length);
}
/* reply. */
dhcp_opt = (uint8_t *)msg + DHCP_OPTIONS_OFS;
/* check. */
if (request_ip)
{
uint32_t client_ip = DHCPD_SERVER_IPADDR0 << 24 | DHCPD_SERVER_IPADDR1 << 16
| DHCPD_SERVER_IPADDR2 << 8 | (next_client_ip);
if (request_ip != client_ip)
{
*dhcp_opt++ = DHCP_OPTION_MESSAGE_TYPE;
*dhcp_opt++ = DHCP_OPTION_MESSAGE_TYPE_LEN;
*dhcp_opt++ = DHCP_NAK;
*dhcp_opt++ = DHCP_OPTION_END;
DEBUG_PRINTF("requested IP invalid, reply DHCP_NAK\n");
if (netif != RT_NULL)
{
int send_byte = (dhcp_opt - (uint8_t *)msg);
_low_level_dhcp_send(netif, msg, send_byte);
DEBUG_PRINTF("DHCP server send %d byte\n", send_byte);
}
next_client_ip++;
if (next_client_ip > DHCPD_CLIENT_IP_MAX)
next_client_ip = DHCPD_CLIENT_IP_MIN;
continue;
}
}
if (message_type == DHCP_DISCOVER)
{
DEBUG_PRINTF("request DHCP_DISCOVER\n");
DEBUG_PRINTF("reply DHCP_OFFER\n");
// DHCP_OPTION_MESSAGE_TYPE
*dhcp_opt++ = DHCP_OPTION_MESSAGE_TYPE;
*dhcp_opt++ = DHCP_OPTION_MESSAGE_TYPE_LEN;
*dhcp_opt++ = DHCP_OFFER;
// DHCP_OPTION_SERVER_ID
*dhcp_opt++ = DHCP_OPTION_SERVER_ID;
*dhcp_opt++ = 4;
*dhcp_opt++ = DHCPD_SERVER_IPADDR0;
*dhcp_opt++ = DHCPD_SERVER_IPADDR1;
*dhcp_opt++ = DHCPD_SERVER_IPADDR2;
*dhcp_opt++ = DHCPD_SERVER_IPADDR3;
// DHCP_OPTION_LEASE_TIME
*dhcp_opt++ = DHCP_OPTION_LEASE_TIME;
*dhcp_opt++ = 4;
*dhcp_opt++ = 0x00;
*dhcp_opt++ = 0x01;
*dhcp_opt++ = 0x51;
*dhcp_opt++ = 0x80;
}
else if (message_type == DHCP_REQUEST)
{
DEBUG_PRINTF("request DHCP_REQUEST\n");
DEBUG_PRINTF("reply DHCP_ACK\n");
// DHCP_OPTION_MESSAGE_TYPE
*dhcp_opt++ = DHCP_OPTION_MESSAGE_TYPE;
*dhcp_opt++ = DHCP_OPTION_MESSAGE_TYPE_LEN;
*dhcp_opt++ = DHCP_ACK;
// DHCP_OPTION_SERVER_ID
*dhcp_opt++ = DHCP_OPTION_SERVER_ID;
*dhcp_opt++ = 4;
*dhcp_opt++ = DHCPD_SERVER_IPADDR0;
*dhcp_opt++ = DHCPD_SERVER_IPADDR1;
*dhcp_opt++ = DHCPD_SERVER_IPADDR2;
*dhcp_opt++ = DHCPD_SERVER_IPADDR3;
// DHCP_OPTION_SUBNET_MASK
*dhcp_opt++ = DHCP_OPTION_SUBNET_MASK;
*dhcp_opt++ = 4;
*dhcp_opt++ = 0xFF;
*dhcp_opt++ = 0xFF;
*dhcp_opt++ = 0xFF;
*dhcp_opt++ = 0x00;
#ifdef DHCPD_USING_ROUTER
// DHCP_OPTION_ROUTER
*dhcp_opt++ = DHCP_OPTION_ROUTER;
*dhcp_opt++ = 4;
*dhcp_opt++ = DHCPD_SERVER_IPADDR0;
*dhcp_opt++ = DHCPD_SERVER_IPADDR1;
*dhcp_opt++ = DHCPD_SERVER_IPADDR2;
*dhcp_opt++ = 1;
#endif
// DHCP_OPTION_DNS_SERVER, use the default DNS server address in lwIP
*dhcp_opt++ = DHCP_OPTION_DNS_SERVER;
*dhcp_opt++ = 4;
*dhcp_opt++ = 208;
*dhcp_opt++ = 67;
*dhcp_opt++ = 222;
*dhcp_opt++ = 222;
// DHCP_OPTION_LEASE_TIME
*dhcp_opt++ = DHCP_OPTION_LEASE_TIME;
*dhcp_opt++ = 4;
*dhcp_opt++ = 0x00;
*dhcp_opt++ = 0x01;
*dhcp_opt++ = 0x51;
*dhcp_opt++ = 0x80;
}
else
{
DEBUG_PRINTF("un handle message:%d\n", message_type);
}
// append DHCP_OPTION_END
*dhcp_opt++ = DHCP_OPTION_END;
/* send reply. */
if ((message_type == DHCP_DISCOVER) || (message_type == DHCP_REQUEST))
{
msg->op = DHCP_BOOTREPLY;
IP4_ADDR(&msg->yiaddr,
DHCPD_SERVER_IPADDR0, DHCPD_SERVER_IPADDR1,
DHCPD_SERVER_IPADDR2, next_client_ip);
client_addr.sin_addr.s_addr = INADDR_BROADCAST;
if (netif != RT_NULL)
{
int send_byte = (dhcp_opt - (uint8_t *)msg);
_low_level_dhcp_send(netif, msg, send_byte);
DEBUG_PRINTF("DHCP server send %d byte\n", send_byte);
}
}
} /* handler. */
}
}
void dhcpd_start(char* netif_name)
{
rt_thread_t thread;
struct netif *netif = RT_NULL;
/* find ethernet interface. */
netif = netif_find(netif_name);
if (netif == RT_NULL)
{
DEBUG_PRINTF("Not found network interface:%s\n", netif_name);
}
thread = rt_thread_create("dhcpd",
dhcpd_thread_entry, netif,
1024,
RT_THREAD_PRIORITY_MAX - 3,
2);
if (thread != RT_NULL)
{
rt_thread_startup(thread);
}
}

36
components/net/lwip_dhcpd/dhcp_server.h Normal file
View File

@ -0,0 +1,36 @@
/*
* File : dhcp_server.h
* A simple DHCP server implementation
*
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2013-2015, Shanghai Real-Thread Technology Co., Ltd
* http://www.rt-thread.com
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2013-01-30 aozima the first version
* 2013-08-08 aozima support different network segments.
* 2015-01-30 bernard release to RT-Thread RTOS.
*/
#ifndef DHCPV4_SERVER_H__
#define DHCPV4_SERVER_H__
void dhcpd_start(char* netif_name);
#endif

21
components/net/lwip_nat/ipv4_nat.c
View File

@ -103,6 +103,7 @@
#include "lwip/udp.h" #include "lwip/udp.h"
#include "lwip/mem.h" #include "lwip/mem.h"
#include "lwip/sys.h" #include "lwip/sys.h"
#include "lwip/timers.h"
#include "netif/etharp.h" #include "netif/etharp.h"
#include <limits.h> #include <limits.h>
@ -116,9 +117,10 @@
#define LWIP_NAT_TTL_INFINITE (INT_MAX) #define LWIP_NAT_TTL_INFINITE (INT_MAX)
#define LWIP_NAT_DEFAULT_TTL_SECONDS (128) #define LWIP_NAT_DEFAULT_TTL_SECONDS (128)
#define LWIP_NAT_FORWARD_HEADER_SIZE_MIN (sizeof(struct eth_hdr)) #define LWIP_NAT_FORWARD_HEADER_SIZE_MIN (sizeof(struct eth_hdr))
#define LWIP_NAT_DEFAULT_STATE_TABLES_ICMP (2)
#define LWIP_NAT_DEFAULT_STATE_TABLES_TCP (16) #define LWIP_NAT_DEFAULT_STATE_TABLES_ICMP (4)
#define LWIP_NAT_DEFAULT_STATE_TABLES_UDP (16) #define LWIP_NAT_DEFAULT_STATE_TABLES_TCP (32)
#define LWIP_NAT_DEFAULT_STATE_TABLES_UDP (32)
#define LWIP_NAT_DEFAULT_TCP_SOURCE_PORT (40000) #define LWIP_NAT_DEFAULT_TCP_SOURCE_PORT (40000)
#define LWIP_NAT_DEFAULT_UDP_SOURCE_PORT (40000) #define LWIP_NAT_DEFAULT_UDP_SOURCE_PORT (40000)
@ -391,7 +393,7 @@ ip_nat_shallnat(const struct ip_hdr *iphdr)
ip_nat_conf_t *nat_config = ip_nat_cfg; ip_nat_conf_t *nat_config = ip_nat_cfg;
for (nat_config = ip_nat_cfg; nat_config != NULL; nat_config = nat_config->next) { for (nat_config = ip_nat_cfg; nat_config != NULL; nat_config = nat_config->next) {
if (ip_addr_netcmp(&(iphdr->dest), &(nat_config->entry.dest_net), if (ip_addr_netcmp(&(iphdr->dest), &(nat_config->entry.dest_net),
&(nat_config->entry.dest_netmask)) || &(nat_config->entry.dest_netmask)) ||
ip_addr_netcmp(&(iphdr->src), &(nat_config->entry.source_net), ip_addr_netcmp(&(iphdr->src), &(nat_config->entry.source_net),
&(nat_config->entry.source_netmask))) { &(nat_config->entry.source_netmask))) {
@ -537,6 +539,7 @@ ip_nat_input(struct pbuf *p)
q = pbuf_alloc(PBUF_LINK, 0, PBUF_RAM); q = pbuf_alloc(PBUF_LINK, 0, PBUF_RAM);
if (q == NULL) { if (q == NULL) {
LWIP_DEBUGF(LWIP_NAT_DEBUG, ("ip_nat_input: no pbuf for outgoing header\n")); LWIP_DEBUGF(LWIP_NAT_DEBUG, ("ip_nat_input: no pbuf for outgoing header\n"));
// rt_kprintf("ip_nat_input: no pbuf for outgoing header\n");
/* @todo: stats? */ /* @todo: stats? */
pbuf_free(p); pbuf_free(p);
p = NULL; p = NULL;
@ -548,11 +551,13 @@ ip_nat_input(struct pbuf *p)
/* restore p->payload to IP header */ /* restore p->payload to IP header */
if (pbuf_header(p, -PBUF_LINK_HLEN)) { if (pbuf_header(p, -PBUF_LINK_HLEN)) {
LWIP_DEBUGF(LWIP_NAT_DEBUG, ("ip_nat_input: restoring header failed\n")); LWIP_DEBUGF(LWIP_NAT_DEBUG, ("ip_nat_input: restoring header failed\n"));
// rt_kprintf("ip_nat_input: restoring header failed\n");
/* @todo: stats? */ /* @todo: stats? */
pbuf_free(p); pbuf_free(p);
p = NULL; p = NULL;
return 1; return 1;
} }
else q = p;
} }
/* if we come here, q is the pbuf to send (either points to p or to a chain) */ /* if we come here, q is the pbuf to send (either points to p or to a chain) */
in_if = nat_entry.cmn->cfg->entry.in_if; in_if = nat_entry.cmn->cfg->entry.in_if;
@ -571,6 +576,7 @@ ip_nat_input(struct pbuf *p)
LWIP_DEBUGF(LWIP_NAT_DEBUG, LWIP_DEBUGF(LWIP_NAT_DEBUG,
("ip_nat_input: failed to send rewritten packet. link layer returned %d\n", ("ip_nat_input: failed to send rewritten packet. link layer returned %d\n",
err)); err));
// rt_kprintf("ip_nat_input: failed to send rewritten packet. link layer returned %d\n", err);
} }
/* now that q (and/or p) is sent (or not), give up the reference to it /* now that q (and/or p) is sent (or not), give up the reference to it
this frees the input pbuf (p) as we have consumed it. */ this frees the input pbuf (p) as we have consumed it. */
@ -735,6 +741,7 @@ ip_nat_out(struct pbuf *p)
if (err != ERR_OK) { if (err != ERR_OK) {
LWIP_DEBUGF(LWIP_NAT_DEBUG, LWIP_DEBUGF(LWIP_NAT_DEBUG,
("ip_nat_out: failed to send rewritten packet. link layer returned %d\n", err)); ("ip_nat_out: failed to send rewritten packet. link layer returned %d\n", err));
// rt_kprintf("ip_nat_out: failed to send rewritten packet. link layer returned %d\n", err);
} else { } else {
sent = 1; sent = 1;
} }
@ -841,6 +848,7 @@ ip_nat_udp_lookup_outgoing(ip_nat_conf_t *nat_config, const struct ip_hdr *iphdr
nat_entry.udp); nat_entry.udp);
} else { } else {
LWIP_DEBUGF(LWIP_NAT_DEBUG, ("ip_nat_udp_lookup_outgoing: no more NAT entries available\n")); LWIP_DEBUGF(LWIP_NAT_DEBUG, ("ip_nat_udp_lookup_outgoing: no more NAT entries available\n"));
// rt_kprintf("ip_nat_udp_lookup_outgoing: no more NAT entries available\n");
} }
} }
} }
@ -925,6 +933,7 @@ ip_nat_tcp_lookup_outgoing(ip_nat_conf_t *nat_config, const struct ip_hdr *iphdr
nat_entry.tcp); nat_entry.tcp);
} else { } else {
LWIP_DEBUGF(LWIP_NAT_DEBUG, ("ip_nat_udp_lookup_outgoing: no more NAT entries available\n")); LWIP_DEBUGF(LWIP_NAT_DEBUG, ("ip_nat_udp_lookup_outgoing: no more NAT entries available\n"));
// rt_kprintf("ip_nat_udp_lookup_outgoing: no more NAT entries available\n");
} }
} }
} }
@ -1004,9 +1013,9 @@ ip_nat_dbg_dump(const char *msg, const struct ip_hdr *iphdr)
LWIP_ASSERT("NULL != msg", NULL != msg); LWIP_ASSERT("NULL != msg", NULL != msg);
LWIP_ASSERT("NULL != iphdr", NULL != iphdr); LWIP_ASSERT("NULL != iphdr", NULL != iphdr);
LWIP_DEBUGF(LWIP_NAT_DEBUG, ("%s: IP: (", msg)); LWIP_DEBUGF(LWIP_NAT_DEBUG, ("%s: IP: (", msg));
ip_nat_dbg_dump_ip(&iphdr->src); ip_nat_dbg_dump_ip((ip_addr_t *)&(iphdr->src));
LWIP_DEBUGF(LWIP_NAT_DEBUG, (" --> ")); LWIP_DEBUGF(LWIP_NAT_DEBUG, (" --> "));
ip_nat_dbg_dump_ip(&iphdr->dest); ip_nat_dbg_dump_ip((ip_addr_t *)&(iphdr->dest));
LWIP_DEBUGF(LWIP_NAT_DEBUG, (" id=%" U16_F ", chksum=%" U16_F ")\n", LWIP_DEBUGF(LWIP_NAT_DEBUG, (" id=%" U16_F ", chksum=%" U16_F ")\n",
ntohs(IPH_ID(iphdr)), ntohs(IPH_CHKSUM(iphdr)))); ntohs(IPH_ID(iphdr)), ntohs(IPH_CHKSUM(iphdr))));
} }