p71924506
/
kernel_liteos_a1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Description: add dhcps and tftpc 

Reviewed-by: jianghan
This commit is contained in:
c00546070 2020-09-22 18:38:46 +08:00 committed by caoruihong 00546070
parent 9b25a48dd4
commit 4f55f678c1
18 changed files with 3225 additions and 405 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
net/lwip-2.1/Makefile
View File

@ -44,7 +44,7 @@ LOCAL_FLAGS += $(LOCAL_INCLUDE)
LOCAL_SRCS := $(wildcard porting/src/*.c $(LWIPNOAPPSFILES))
LOCAL_SRCS += $(wildcard enhancement/src/*.c)
LOCAL_SRCS += $(wildcard $(LWIPDIR)/core/ipv4/dhcps.c)
LOCAL_SRCS := $(filter-out $(LWIPDIR)/core/ipv4/dhcp.c, $(LOCAL_SRCS))
LOCAL_SRCS := $(filter-out $(LWIPDIR)/core/ipv4/etharp.c, $(LOCAL_SRCS))
LOCAL_SRCS := $(filter-out $(LWIPDIR)/api/sockets.c, $(LOCAL_SRCS))

102
net/lwip-2.1/enhancement/include/dhcps_fix.h
View File

@ -1,102 +0,0 @@
/*
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
*
* 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 of the copyright holder 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 HOLDER 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.
*/
#ifndef LITEOS_A_DHCPS_FIXME_H
#define LITEOS_A_DHCPS_FIXME_H
#include "lwip/opt.h"
#if (LWIP_DHCP) && (LWIP_DHCPS)
#define LWIP_STATIC static
/* Option handling: options are parsed in dhcp_parse_reply
* and saved in an array where other functions can load them from.
* This might be moved into the struct dhcp (not necessarily since
* lwIP is single-threaded and the array is only used while in recv
* callback). */
enum dhcp_option_idx {
DHCP_OPTION_IDX_OVERLOAD = 0,
DHCP_OPTION_IDX_MSG_TYPE,
DHCP_OPTION_IDX_SERVER_ID,
DHCP_OPTION_IDX_LEASE_TIME,
DHCP_OPTION_IDX_T1,
DHCP_OPTION_IDX_T2,
DHCP_OPTION_IDX_SUBNET_MASK,
DHCP_OPTION_IDX_ROUTER,
#if LWIP_DHCP_PROVIDE_DNS_SERVERS
DHCP_OPTION_IDX_DNS_SERVER,
DHCP_OPTION_IDX_DNS_SERVER_LAST = DHCP_OPTION_IDX_DNS_SERVER + LWIP_DHCP_PROVIDE_DNS_SERVERS - 1,
#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */
#if LWIP_DHCP_GET_NTP_SRV
DHCP_OPTION_IDX_NTP_SERVER,
DHCP_OPTION_IDX_NTP_SERVER_LAST = DHCP_OPTION_IDX_NTP_SERVER + LWIP_DHCP_MAX_NTP_SERVERS - 1,
#endif /* LWIP_DHCP_GET_NTP_SRV */
DHCP_OPTION_IDX_REQUESTED_IP,
DHCP_OPTION_IDX_MAX
};
#define DHCP_OPTION_ROUTER_SIZE 4
#define DHCP_OPTION_SUBNET_MASK_SIZE 4
#define DHCP_OPTION_LEASE_TIME_SIZE 4
#define DHCP_OPTION_SERVER_ID_LEN 4
#define DHCP_OPTION_T1_LEN 4
#define DHCP_OPTION_T2_LEN 4
#define DHCP_CLIENT_PORT 68
#define DHCP_SERVER_PORT 67
#define DHCP_BROADCAST_FLAG 0x8000
#define DHCP_MAX_MSG_LEN_MIN_REQUIRED 576
struct dyn_lease_addr {
u8_t cli_hwaddr[DHCP_CHADDR_LEN];
u32_t flags;
u32_t leasetime;
u32_t proposed_leasetime;
ip4_addr_t cli_addr;
};
struct dhcps {
struct udp_pcb *pcb;
struct dyn_lease_addr leasearr[LWIP_DHCPS_MAX_LEASE];
u8_t pcb_allocated;
u8_t lease_num;
struct netif *netif;
ip4_addr_t start_addr;
ip4_addr_t end_addr;
};
#endif // (LWIP_DHCP) && (LWIP_DHCPS)
#endif // LITEOS_A_DHCPS_FIXME_H

8
net/lwip-2.1/enhancement/include/api_shell.h → net/lwip-2.1/enhancement/include/lwip/api_shell.h
View File

@ -29,8 +29,8 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef LWIP_API_SHELL_H
#define LWIP_API_SHELL_H
#ifndef LWIP_HDR_API_SHELL_H
#define LWIP_HDR_API_SHELL_H
#include "arch/cc.h"
#include "lwip/opt.h"
@ -58,6 +58,4 @@ void netstat_internal(void *ctx);
}
#endif
#endif
#endif /* LWIP_HDR_API_SHELL_H */

10
net/lwip-2.1/enhancement/include/dhcps.h → net/lwip-2.1/enhancement/include/lwip/dhcps.h
View File

@ -63,16 +63,6 @@ extern "C" {
err_t dhcps_start(struct netif *netif, const char *start_ip, u16_t ip_num);
void dhcps_stop(struct netif *netif);
void dhcp_common_option(struct dhcp_msg *msg_out, u8_t option_type, u8_t option_len, u16_t *options_out_len);
void dhcp_common_option_byte(struct dhcp_msg *msg_out, u8_t value, u16_t *options_out_len);
void dhcp_common_option_short(struct dhcp_msg *msg_out, u16_t value, u16_t *options_out_len);
void dhcp_common_option_long(struct dhcp_msg *msg_out, u32_t value, u16_t *options_out_len);
void dhcp_common_option_trailer(struct dhcp_msg *msg_out, u16_t *options_out_len);
#if LWIP_DHCP_BOOTP_FILE
err_t dhcps_parse_options(struct pbuf *p, char *boot_file_name);
#else
err_t dhcps_parse_options(struct pbuf *p);
#endif
#if defined (__cplusplus) && __cplusplus
}

141
net/lwip-2.1/enhancement/include/api_shell_fix.h → net/lwip-2.1/enhancement/include/lwip/fixme.h
View File

@ -29,17 +29,12 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef LITEOS_A_FIXME_H
#define LITEOS_A_FIXME_H
#define LWIP_ENABLE_LOS_SHELL_CMD 1
#define LWIP_ENABLE_IP_CONFLICT_SIGNAL 0
#define PF_PKT_SUPPORT 1
#define NETCONN_PKT_RAW 0x80
#ifndef LWIP_HDR_FIXME_H
#define LWIP_HDR_FIXME_H
#include "lwip/opt.h"
#if LWIP_ENABLE_LOS_SHELL_CMD
#include "netif/etharp.h"
#include "lwip/netif.h"
#define link_rx_drop cachehit
#define link_tx_drop cachehit
@ -51,78 +46,37 @@
#define ip_rx_bytes cachehit
#define ip_tx_bytes cachehit
#define LWIP_STATIC static
#define SYS_ARCH_ERROR SYS_ARCH_TIMEOUT
#define DUP_ARP_DETECT_TIME 2000 /* 2 seconds period */
#define SOF_BINDNONUNICAST 0x0800U /* socket has bind to a non unicast */
#define NETCONN_PKT_RAW 0x80
#define SYS_ARCH_ERROR SYS_ARCH_TIMEOUT
#include "netif/etharp.h"
#include "lwip/netif.h"
#define LWIP_SHELL_CMD_PING_RETRY_TIMES 4
#define LWIP_ENABLE_LOS_SHELL_CMD LOSCFG_SHELL
#define LWIP_SHELL_CMD_PING_RETRY_TIMES 4
#define LWIP_SHELL_CMD_PING_TIMEOUT 2000
#define LWIP_MAX_UDP_RAW_SEND_SIZE 65332
#define LWIP_EXT_POLL_SUPPORT LWIP_SOCKET_POLL
#define TRANSFER_MODE_BINARY 1
u32_t lwip_tftp_get_file_by_filename(u32_t ulHostAddr,
u16_t usTftpServPort,
u8_t ucTftpTransMode,
s8_t *szSrcFileName,
s8_t *szDestDirPath);
u32_t lwip_tftp_put_file_by_filename(u32_t ulHostAddr,
u16_t usTftpServPort,
u8_t cTftpTransMode,
s8_t *szSrcFileName,
s8_t *szDestDirPath);
#define ip_addr_set_val(dest, src) do { IP_SET_TYPE_VAL(*dest, IP_GET_TYPE(src)); if(IP_IS_V6_VAL(*(src))) { \
ip6_addr_set(ip_2_ip6(dest), ip_2_ip6(src)); } else { \
ip4_addr_set(ip_2_ip4(dest), ip_2_ip4(src)); }} while (0)
#define ip_addr_set_val(dest, src) do { \
IP_SET_TYPE_VAL(*dest, IP_GET_TYPE(src)); \
if(IP_IS_V6_VAL(*(src))) { \
ip6_addr_set(ip_2_ip6(dest), ip_2_ip6(src)); \
} else { \
ip4_addr_set(ip_2_ip4(dest), ip_2_ip4(src)); \
} \
} while (0)
#define ip_addr_ismulticast_val(ipaddr) ((IP_IS_V6_VAL(*ipaddr)) ? \
ip6_addr_ismulticast(ip_2_ip6(ipaddr)) : \
ip4_addr_ismulticast(ip_2_ip4(ipaddr)))
ip6_addr_ismulticast(ip_2_ip6(ipaddr)) : \
ip4_addr_ismulticast(ip_2_ip4(ipaddr)))
#define ip_addr_isbroadcast_val(ipaddr, netif) ((IP_IS_V6_VAL(*ipaddr)) ? \
0 : \
ip4_addr_isbroadcast(ip_2_ip4(ipaddr), netif))
0 : \
ip4_addr_isbroadcast(ip_2_ip4(ipaddr), netif))
#define ip_addr_netcmp_val(addr1, addr2, mask) ((IP_IS_V6_VAL(*(addr1)) && IP_IS_V6_VAL(*(addr2))) ? \
0 : \
ip4_addr_netcmp(ip_2_ip4(addr1), ip_2_ip4(addr2), mask))
#if LWIP_DHCP
/*
* Close DHCP and set static network.
*
* @param netif a pre-allocated netif structure
*
* @return ERR_OK, or ERR_VAL if failed.
*/
err_t netif_dhcp_off(struct netif *netif);
#endif /* LWIP_DHCP */
#include "lwip/prot/dhcp.h"
err_t netif_do_rmv_ipv6_addr(struct netif *netif, void *arguments);
err_t netif_set_mtu(struct netif *netif, u16_t netif_mtu);
err_t netif_set_hwaddr(struct netif *netif, const unsigned char *hw_addr, int hw_len);
struct netif *netifapi_netif_find_by_name(const char *name);
/* 2 seconds period */
#define DUP_ARP_DETECT_TIME 2000
err_t etharp_update_arp_entry(struct netif *netif, const ip4_addr_t *ipaddr, struct eth_addr *ethaddr, u8_t flags);
err_t etharp_delete_arp_entry(struct netif *netif, ip4_addr_t *ipaddr);
#define LWIP_MAX_UDP_RAW_SEND_SIZE 65332
0 : \
ip4_addr_netcmp(ip_2_ip4(addr1), ip_2_ip4(addr2), mask))
#define ip6_addr_isnone_val(ip6addr) (((ip6addr).addr[0] == 0xffffffffUL) && \
((ip6addr).addr[1] == 0xffffffffUL) && \
@ -131,20 +85,7 @@ err_t etharp_delete_arp_entry(struct netif *netif, ip4_addr_t *ipaddr);
#define ip6_addr_isnone(ip6addr) (((ip6addr) == NULL) || ip6_addr_isnone_val(*(ip6addr)))
err_t lwip_dns_setserver(u8_t numdns, ip_addr_t *dnsserver);
err_t lwip_dns_getserver(u8_t numdns, ip_addr_t *dnsserver);
#define ipaddr_ntoa_unsafe(addr) ((IP_IS_V6_VAL(*addr)) ? ip6addr_ntoa(ip_2_ip6(addr)) : ip4addr_ntoa(ip_2_ip4(addr)))
#define SOF_BINDNONUNICAST 0x0800U /* socket has bind to a non unicast */
#if PF_PKT_SUPPORT
extern struct raw_pcb *pkt_raw_pcbs;
#endif
extern struct raw_pcb *raw_pcbs;
#define ipaddr_ntoa_unsafe(addr) ((IP_IS_V6_VAL(*addr)) ? ip6addr_ntoa(ip_2_ip6(addr)) : ip4addr_ntoa(ip_2_ip4(addr)))
#ifdef ip6_addr_cmp
#undef ip6_addr_cmp
@ -152,10 +93,30 @@ extern struct raw_pcb *raw_pcbs;
((addr1)->addr[1] == (addr2)->addr[1]) && \
((addr1)->addr[2] == (addr2)->addr[2]) && \
((addr1)->addr[3] == (addr2)->addr[3]))
#endif //ip6_addr_cmp
#endif
#define LWIP_EXT_POLL_SUPPORT LWIP_SOCKET_POLL
err_t netif_dhcp_off(struct netif *netif);
#endif //LWIP_ENABLE_LOS_SHELL_CMD
err_t netif_do_rmv_ipv6_addr(struct netif *netif, void *arguments);
#endif //LITEOS_A_FIXME_H
err_t netif_set_mtu(struct netif *netif, u16_t netif_mtu);
err_t netif_set_hwaddr(struct netif *netif, const unsigned char *hw_addr, int hw_len);
err_t etharp_update_arp_entry(struct netif *netif, const ip4_addr_t *ipaddr, struct eth_addr *ethaddr, u8_t flags);
err_t etharp_delete_arp_entry(struct netif *netif, ip4_addr_t *ipaddr);
err_t lwip_dns_setserver(u8_t numdns, ip_addr_t *dnsserver);
err_t lwip_dns_getserver(u8_t numdns, ip_addr_t *dnsserver);
#if PF_PKT_SUPPORT
extern struct raw_pcb *pkt_raw_pcbs;
#endif
#if LWIP_RAW
extern struct raw_pcb *raw_pcbs;
#endif
#endif /* LWIP_HDR_FIXME_H */

310
net/lwip-2.1/enhancement/include/lwip/tftpc.h Normal file
View File

@ -0,0 +1,310 @@
/*
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
*
* 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 of the copyright holder 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 HOLDER 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.
*/
#ifndef LWIP_HDR_TFTPC_H
#define LWIP_HDR_TFTPC_H
#include "lwip/opt.h"
#include "lwip/sockets.h"
#if LWIP_TFTP /* don't build if not configured for use in lwipopts.h */
#if defined (__cplusplus) && __cplusplus
extern "C" {
#endif
#define TFTP_NULL_UINT32 ((u32_t)0xffffffffUL)
#define TFTP_NULL_INT32 -1
/** @cond liteos
* @defgroup TFTP_Interfaces
* @ingroup Enums
* * This section contains the TFTP enums.
*/
/**
*
* This Enum is used to specify the transfer mode of the file to be handled by TFTP client.
*/
typedef enum tagTFTPC_TransferMode {
TRANSFER_MODE_ASCII = 0, /**< Indicates that the mode of transfer is ASCII. */
TRANSFER_MODE_BINARY, /**< Indicates that the mode of transfer is Binary */
TRANSFER_MODE_BUTT /**< Indicates invalid transfer mode.*/
} TFTPC_TRANSFER_MODE_E;
/**
* This Enum is used to specify the transfer mode to be handled by TFTP client
* This Enum indicates the TFTP client transfer mode of the file
*/
typedef enum tagTFTPC_ErrCode {
TFTPC_SOCKET_FAILURE = 1, /**< Error while creating UDP socket. */
TFTPC_BIND_FAILURE = 2, /**< Error while binding to the UDP socket. */
TFTPC_SELECT_ERROR = 3, /**< Error returned by select() system call. */
TFTPC_RECVFROM_ERROR = 4, /**< Error while receiving data from the peer. */
TFTPC_SENDTO_ERROR = 5, /**< Error while sending data to the peer. */
TFTPC_FILE_NOT_FOUND = 6, /**< Requested file is not found. */
/**< This is the error sent by the server when host name cannot be resolved. */
TFTPC_CANNOT_RESOLVE_HOSTNAME = 7,
TFTPC_INVALID_PARAVALUE = 8, /**< Input parameters passed to TFTP interfaces are invalid. */
/**< Error detected in TFTP packet or the error received from the TFTP server. */
TFTPC_PROTO_ERROR = 9,
/**< Error during packet synchronization while sending or unexpected packet is received. */
TFTPC_SYNC_FAILURE = 10,
/**< File size limit crossed, Max block can be 0xFFFF, each block containing 512 bytes. */
TFTPC_FILE_TOO_BIG = 11,
TFTPC_SRC_FILENAME_LENGTH_ERROR = 12, /**< File name length greater than 256. */
TFTPC_IP_NOT_WITHIN_RANGE = 13, /**< Host name IP is not valid. */
TFTPC_ACCESS_ERROR = 14, /**< TFTP server returned file access error. */
/**< TFTP server returned error signifying that the DISK is full to write. */
TFTPC_DISK_FULL = 15,
TFTPC_FILE_EXISTS = 16, /**< TFTP server returned error signifying that the file exists. */
/**< tftp_put_file_by_filename returned error signifying that the source file name do not exist. */
TFTPC_FILE_NOT_EXIST = 17,
TFTPC_MEMALLOC_ERROR = 18, /**< Memory allocation failed in TFTP client. */
TFTPC_FILEOPEN_ERROR = 19, /**< File open failed. */
TFTPC_FILEREAD_ERROR = 20, /**< File read error. */
TFTPC_FILECREATE_ERROR = 21, /**< File create error. */
TFTPC_FILEWRITE_ERROR = 22, /**< File write error. */
TFTPC_TIMEOUT_ERROR = 23, /**< Max time expired while waiting for file to be received. */
/**< Error when the received packet is less than 4 bytes (error length) or greater than 512 bytes. */
TFTPC_PKT_SIZE_ERROR = 24,
TFTPC_ERROR_NOT_DEFINED = 25, /**< Returned by TFTP server for protocol user error. */
TFTPC_DEST_PATH_LENGTH_ERROR = 26, /**< If the destination file path length is greater than 256. */
TFTPC_UNKNOWN_TRANSFER_ID = 27, /**< Returned by TFTP server for undefined transfer ID. */
/**< IOCTL function failed at TFTP client while setting the socket to non-block. */
TFTPC_IOCTLSOCKET_FAILURE = 28,
TFTPC_MEMCPY_FAILURE = 29 /**< TFTP memcpy failure. */
} TFTPC_ERR_CODE_E;
typedef enum tagTFTPC_OpCode {
TFTPC_OP_RRQ = 1, /* read request */
TFTPC_OP_WRQ, /* write request */
TFTPC_OP_DATA, /* data packet */
TFTPC_OP_ACK, /* acknowledgement */
TFTPC_OP_ERROR, /* error code */
TFTPC_OP_OPT /* option code */
} TFTPC_OPCODE_E;
typedef enum tagTFTPC_PROTOCOL_ErrCode {
TFTPC_PROTOCOL_USER_DEFINED = 0,
TFTPC_PROTOCOL_FILE_NOT_FOUND,
TFTPC_PROTOCOL_ACCESS_ERROR,
TFTPC_PROTOCOL_DISK_FULL,
TFTPC_PROTOCOL_PROTO_ERROR,
TFTPC_PROTOCOL_UNKNOWN_TRANSFER_ID,
TFTPC_PROTOCOL_FILE_EXISTS,
TFTPC_PROTOCOL_CANNOT_RESOLVE_HOSTNAME
} TFTPC_PROT_ERRCODE_E;
#ifndef TFTPC_MAX_SEND_REQ_ATTEMPTS
#define TFTPC_MAX_SEND_REQ_ATTEMPTS 5 /* tftp max attempts */
#endif
#ifndef TFTPC_TIMEOUT_PERIOD
#define TFTPC_TIMEOUT_PERIOD 5 /* tftp timeout period,unit :s */
#endif
#define TFTPC_SERVER_PORT 69 /* tftp server well known port no. */
/* MAX file size in TFTP is 32 MB.
Reason for keeping 75 here , is ((75*512=38400bytes)/1024) = 37MB. So the recv/Send Loop can
receive the complete MAX message from the network
*/
#define TFTPC_MAX_WAIT_IN_LOOP 75
#define TFTP_BLKSIZE 512 /* data block size (IEN-133) */
#define TFTP_HDRSIZE 4 /* TFTP header size */
#define TFTP_PKTSIZE (TFTP_BLKSIZE + TFTP_HDRSIZE) /* Packet size */
#define TFTP_MAX_MODE_SIZE 9 /* max size of mode string */
#define TFTP_MAXERRSTRSIZE 100 /* max size of error message string */
#define TFTP_MAX_PATH_LENGTH 256 /* Max path or filename length */
#define TFTP_MAX_BLK_NUM (0xFFFFL) /* MAximum block number */
/* IP address not including reserved IPs(0 and 127) and multicast addresses(Class D) */
#define TFTPC_IP_ADDR_MIN 0x01000000
#define TFTPC_IP_ADDR_EX_RESV 0x7effffff
#define TFTPC_IP_ADDR_CLASS_B 0x80000000
#define TFTPC_IP_ADDR_EX_CLASS_DE 0xdfffffff
#define TFTPC_FOUR 4 /* minimum packet size */
/****************************************************************************/
/* Structure definitions */
/****************************************************************************/
/* Tftp data packet */
typedef struct tagTFTPC_DATA {
u16_t usBlknum; /* block number */
u8_t ucDataBuf[TFTP_BLKSIZE]; /* Actual data */
} TFTPC_DATA_S;
/* TFTP error packet */
typedef struct tagTFTPC_ERROR {
u16_t usErrNum; /* error number */
u8_t ucErrMesg[TFTP_MAXERRSTRSIZE]; /* error message */
} TFTPC_ERROR_S;
/* TFTP packet format */
typedef struct tagTFTPC_PACKET {
u16_t usOpcode; /* Opcode value */
union {
/* it contains mode and filename */
s8_t ucName_Mode[TFTP_MAX_PATH_LENGTH + TFTP_MAX_MODE_SIZE];
u16_t usBlknum; /* Block Number */
TFTPC_DATA_S stTFTP_Data; /* Data Packet */
TFTPC_ERROR_S stTFTP_Err; /* Error Packet */
} u;
} TFTPC_PACKET_S;
/** @defgroup TFTP_Interfaces
* This section contains the TFTP Interfaces
*/
/*
Func Name: lwip_tftp_get_file_by_filename
*/
/**
* @ingroup TFTP_Interfaces
* @brief
* This API gets the source file from the server. It then stores the received file in the destination path
* on the client system.
*
* @param[in] ulHostAddr IP address of Host. This is the TFTP server IP. [NA]
* @param[in] usTftpServPort TFTP server port. If the value is passed as 0 then the default TFTP
* PORT 69 is used. [NA]
* @param[in] ucTftpTransMode File transfer mode, either TRANSFER_MODE_BINARY or TRANSFER_MODE_ASCII. [NA]
* @param[in] szSrcFileName Source file in the tftp server. [NA]
* @param[in] szDestDirPath Destination file path in the in the client. [NA]
* @param[out] [N/A]
*
* @return
* ERR_OK: On success \n
* TFTPC_ERR_CODE_E: On failure
*
* @note
* \n
* The behavior of this API is such that if the destination file already exists, it will be overwritten.
*/
u32_t lwip_tftp_get_file_by_filename(u32_t ulHostAddr,
u16_t usTftpServPort,
u8_t ucTftpTransMode,
s8_t *szSrcFileName,
s8_t *szDestDirPath);
/* @defgroup TFTP_Interfaces
* This section contains the TFTP Interfaces
*/
/*
Func Name: lwip_tftp_put_file_by_filename
*/
/**
* @ingroup TFTP_Interfaces
* @brief
* This API reads the contents of the source file on the client system and sends it to the server and
* server then receives the data and stores it in the specified destination path.
*
* @param[in] ulHostAddr Indicates the IP address of Host. This is the TFTP server IP.
* @param[in] usTftpServPort Indicates the TFTP server port. If the value is passed as 0 then the default TFTP
* PORT 69 is used.
* @param[in] ucTftpTransMode Indicates the file transfer mode, either TRANSFER_MODE_BINARY or TRANSFER_MODE_ASCII.
* @param[in] szSrcFileName Indicates the source file in the client.
* @param[in] szDestDirPath Indicates the destination file path on the tftp server.
*
* @return
* ERR_OK: On success \n
* TFTPC_ERR_CODE_E: On failure
*
*/
u32_t lwip_tftp_put_file_by_filename(u32_t ulHostAddr,
u16_t usTftpServPort,
u8_t cTftpTransMode,
s8_t *szSrcFileName,
s8_t *szDestDirPath);
#ifdef TFTP_TO_RAWMEM
/* @defgroup TFTP_Interfaces
* This section contains the TFTP Interfaces
*/
/*
Func Name: lwip_tftp_get_file_by_filename_to_rawmem
*/
/**
* @ingroup TFTP_Interfaces
* @brief
* This API gets the source file from the server. It then stores the received file in the target memory
* on the client system.
*
* @param[in] ulHostAddr Indicates the IP address of the Host. This is the TFTP server IP.
* @param[in] usTftpServPort Indicates the TFTP server port. If the value is passed as 0 then the default TFTP
* PORT 69 is used.
* @param[in] ucTftpTransMode Indicates the File transfer mode, either TRANSFER_MODE_BINARY or TRANSFER_MODE_ASCII.
* @param[in] szSrcFileName Indicates the Source file in the TFTP server.
* @param[in] szDestMemAddr Indicates the target memory address in the client.
* @param[in/out] ulFileLength Indicates the target memory address can cache the size of the content,
and The real size of the Source file.
*
* @return
* ERR_OK: On success \n
* TFTPC_ERR_CODE_E: On failure
* @note
* 1.You must define TFTP_TO_RAWMEM when using this API. \n
* 2.The behavior of this API is such that if the destination file already exists, it will be overwritten.
* @endcond
*/
u32_t lwip_tftp_get_file_by_filename_to_rawmem(u32_t ulHostAddr,
u16_t usTftpServPort,
u8_t ucTftpTransMode,
s8_t *szSrcFileName,
s8_t *szDestMemAddr,
u32_t *ulFileLength);
#endif
#if defined (__cplusplus) && __cplusplus
}
#endif
#endif /* LWIP_TFTP */
#endif /* LWIP_HDR_TFTPC_H */

9
net/lwip-2.1/enhancement/src/api_shell.c
View File

@ -33,7 +33,7 @@
#define icmp6_hdr netinet_icmp6_hdr
#include <netinet/icmp6.h>
#undef icmp6_hdr
#include "api_shell_fix.h"
#include "lwip/fixme.h"
#include "lwip/opt.h"
#if LWIP_ENABLE_LOS_SHELL_CMD
@ -62,7 +62,8 @@
#include <ctype.h>
#include <poll.h>
#include "api_shell.h"
#include "lwip/api_shell.h"
#include "lwip/tftpc.h"
#include "lwip/dns.h"
#include "lwip/netdb.h"
@ -78,7 +79,7 @@
#include "shell.h"
#endif
#define netif_find netifapi_netif_find_by_name
#define LWIP_STATIC static
#if LWIP_ARP
extern sys_sem_t ip_conflict_detect;
@ -3163,8 +3164,10 @@ void netstat_internal(void *ctx)
int recvQlen = 0;
int sendQlen = 0;
u_int proto;
#if PF_PKT_SUPPORT
u8_t netif_name[IFNAMSIZ];
struct netif *netif = NULL;
#endif
if (ndata == NULL) {
return;

983
net/lwip-2.1/enhancement/src/dhcps.c Normal file
View File

@ -0,0 +1,983 @@
/*
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
*
* 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 of the copyright holder 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 HOLDER 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.
*/
/**
* @file
* Dynamic Host Configuration Protocol Server
*
*/
#include "../core/ipv4/dhcp.c" /* for enum dhcp_option_idx/dhcp_option_xx/dhcp_parse_reply etc. */
#include "lwip/opt.h"
#if (LWIP_DHCP) && (LWIP_DHCPS) /* don't build if not configured for use in lwipopts.h */
#include <string.h>
#include "lwip/stats.h"
#include "lwip/mem.h"
#include "lwip/udp.h"
#include "lwip/ip_addr.h"
#include "lwip/netif.h"
#include "lwip/def.h"
#include "lwip/prot/dhcp.h"
#include "lwip/dhcp.h"
#include "lwip/dhcps.h"
#include "lwip/sys.h"
#include "netif/etharp.h"
#define DHCPS_ADDRESS_FREE 0x0
#define DHCPS_ADDRESS_OFFERRED 0x1
#define DHCPS_ADDRESS_BOUND 0x2
#define DHCPS_ADDRESS_DECLINED 0x3
#define LWIP_STATIC static
#define DHCP_OPTION_ROUTER_SIZE 4
#define DHCP_OPTION_SUBNET_MASK_SIZE 4
#define DHCP_OPTION_LEASE_TIME_SIZE 4
#define DHCP_OPTION_SERVER_ID_LEN 4
#define DHCP_OPTION_T1_LEN 4
#define DHCP_OPTION_T2_LEN 4
#define DHCP_CLIENT_PORT 68
#define DHCP_SERVER_PORT 67
#define DHCP_BROADCAST_FLAG 0x8000
struct dyn_lease_addr {
u8_t cli_hwaddr[DHCP_CHADDR_LEN];
u32_t flags;
u32_t leasetime;
u32_t proposed_leasetime;
ip4_addr_t cli_addr;
};
struct dhcps {
struct dhcp dhcp;
struct udp_pcb *pcb;
struct dyn_lease_addr leasearr[LWIP_DHCPS_MAX_LEASE];
u8_t pcb_allocated;
u8_t lease_num;
struct netif *netif;
ip4_addr_t start_addr;
ip4_addr_t end_addr;
};
#define dhcps_option_given(dhcps, idx) dhcp_option_given(&(dhcps)->dhcp, idx)
#define dhcps_got_option(dhcps, idx) dhcp_got_option(&(dhcps)->dhcp, idx)
#define dhcps_clear_option(dhcps, idx) dhcp_clear_option(&(dhcps)->dhcp, idx)
#define dhcps_clear_all_options(dhcps) dhcp_clear_all_options(&(dhcps)->dhcp)
#define dhcps_get_option_value(dhcps, idx) dhcp_get_option_value(&(dhcps)->dhcp, idx)
#define dhcps_set_option_value(dhcps, idx, val) dhcp_set_option_value(&(dhcps)->dhcp, idx, val)
#define netif_get_dhcps(netif) ((struct dhcps*)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCPS))
#define netif_set_dhcps(netif, dhcps) netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCPS, dhcps)
LWIP_STATIC void dhcp_common_option(struct dhcp_msg *msg_out, u8_t option_type, u8_t option_len, u16_t *options_out_len);
LWIP_STATIC void dhcp_common_option_byte(struct dhcp_msg *msg_out, u8_t value, u16_t *options_out_len);
LWIP_STATIC void dhcp_common_option_long(struct dhcp_msg *msg_out, u32_t value, u16_t *options_out_len);
LWIP_STATIC void dhcp_common_option_trailer(struct dhcp_msg *msg_out, u16_t options_out_len, struct pbuf *p_out);
LWIP_STATIC err_t dhcps_parse_options(struct pbuf *p, struct dhcps *dhcps);
LWIP_STATIC struct pbuf *dhcps_create_base_msg(struct dhcp_msg *client_msg);
LWIP_STATIC void remove_stale_entries(struct dhcps *dhcps);
LWIP_STATIC void add_client_entry(struct dhcps *dhcps, unsigned int idx, struct dhcp_msg *client_msg);
LWIP_STATIC int find_free_slot(struct dhcps *dhcps);
LWIP_STATIC struct dyn_lease_addr *find_client_lease(struct dhcps *dhcps, struct dhcp_msg *client_msg);
LWIP_STATIC ip4_addr_t validate_discover(struct dhcps *dhcps, struct dhcp_msg *client_msg,
struct dyn_lease_addr **client_lease);
LWIP_STATIC void handle_discover(struct netif *netif, struct dhcps *dhcps, struct dhcp_msg *client_msg,
struct dyn_lease_addr *client_lease);
LWIP_STATIC ip4_addr_t validate_request_message(struct netif *netif, struct dhcp_msg *client_msg,
struct dyn_lease_addr *client_lease, ip4_addr_t serverid);
LWIP_STATIC void handle_request(struct netif *netif, struct dhcps *dhcps, struct dhcp_msg *client_msg,
struct dyn_lease_addr *client_lease, ip4_addr_t serverid);
LWIP_STATIC void handle_decline(struct netif *netif, struct dhcps *dhcps, struct dhcp_msg *client_msg,
struct dyn_lease_addr *client_lease);
LWIP_STATIC void handle_inform(struct netif *netif, struct dhcps *dhcps, struct dhcp_msg *client_msg);
LWIP_STATIC void handle_client_messages(struct netif *netif, struct dhcps *dhcps,
struct dhcp_msg *client_msg, ip4_addr_t serverid, u8_t msg_type);
LWIP_STATIC void dhcps_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p,
const ip_addr_t *ip_addr, u16_t port);
LWIP_STATIC struct pbuf *dhcps_create_base_msg(struct dhcp_msg *client_msg)
{
struct pbuf *srvr_msg_pbuf = NULL;
struct dhcp_msg *srvr_msg = NULL;
srvr_msg_pbuf = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcp_msg), PBUF_RAM);
if (srvr_msg_pbuf == NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS,
("dhcps_create_base_msg(): could not allocate pbuf\n"));
return NULL;
}
LWIP_ASSERT("dhcps_create_base_msg: check that first pbuf can hold struct dhcp_msg",
(srvr_msg_pbuf->len >= sizeof(struct dhcp_msg)));
#if DRIVER_STATUS_CHECK
srvr_msg_pbuf->flags |= PBUF_FLAG_DHCP_BUF;
#endif
srvr_msg = (struct dhcp_msg *)srvr_msg_pbuf->payload;
srvr_msg->op = DHCP_BOOTREPLY;
srvr_msg->htype = client_msg->htype;
srvr_msg->hlen = client_msg->hlen;
srvr_msg->hops = 0;
srvr_msg->xid = client_msg->xid;
srvr_msg->secs = 0;
srvr_msg->flags = client_msg->flags;
ip4_addr_set_zero(&srvr_msg->ciaddr);
ip4_addr_set_zero(&srvr_msg->yiaddr);
ip4_addr_set_zero(&srvr_msg->siaddr);
ip4_addr_copy(srvr_msg->giaddr, client_msg->giaddr);
if (memcpy_s(srvr_msg->chaddr, sizeof(srvr_msg->chaddr), client_msg->chaddr, DHCP_CHADDR_LEN) != EOK) {
(void)pbuf_free(srvr_msg_pbuf);
return NULL;
}
(void)memset_s(srvr_msg->sname, sizeof(srvr_msg->sname), 0, DHCP_SNAME_LEN);
(void)memset_s(srvr_msg->file, sizeof(srvr_msg->file), 0, DHCP_FILE_LEN);
srvr_msg->cookie = PP_HTONL(DHCP_MAGIC_COOKIE);
return srvr_msg_pbuf;
}
LWIP_STATIC void remove_stale_entries(struct dhcps *dhcps)
{
int i = 0;
u32_t curr_time = sys_now();
for (i = 0; i < dhcps->lease_num; i++) {
/* Slot should not be free or have infinite lease time */
if ((dhcps->leasearr[i].flags != DHCPS_ADDRESS_FREE) && (dhcps->leasearr[i].leasetime != (u32_t)~0)) {
if (dhcps->leasearr[i].leasetime < curr_time) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("remove_stale_entries: Removing Client Entry at Index = %"U32_F"\n", i));
(void)memset_s(&(dhcps->leasearr[i]), sizeof(struct dyn_lease_addr), 0, sizeof(struct dyn_lease_addr));
dhcps->leasearr[i].flags = DHCPS_ADDRESS_FREE;
}
}
}
}
LWIP_STATIC void add_client_entry(struct dhcps *dhcps, unsigned int idx, struct dhcp_msg *client_msg)
{
u32_t client_lease_time = (u32_t)(LWIP_DHCPS_LEASE_TIME);
if ((dhcps_option_given(dhcps, DHCP_OPTION_IDX_LEASE_TIME))
#if (LWIP_DHCPS_LEASE_TIME != ~0)
&& (dhcps_get_option_value(dhcps, DHCP_OPTION_IDX_LEASE_TIME) < LWIP_DHCPS_LEASE_TIME)
#endif
) {
client_lease_time = (u32_t)dhcps_get_option_value(dhcps, DHCP_OPTION_IDX_LEASE_TIME);
}
(void)memset_s(&(dhcps->leasearr[idx]), sizeof(struct dyn_lease_addr), 0, sizeof(struct dyn_lease_addr));
if (memcpy_s(dhcps->leasearr[idx].cli_hwaddr, DHCP_CHADDR_LEN,
client_msg->chaddr, sizeof(client_msg->chaddr)) != EOK) {
return;
}
/* This is called only during offer message, so adding offer time.
This is later updated to lease time when request message is handled */
dhcps->leasearr[idx].leasetime = sys_now() + (LWIP_DHCPS_OFFER_TIME * 1000);
dhcps->leasearr[idx].cli_addr.addr = dhcps->start_addr.addr + idx;
dhcps->leasearr[idx].flags = DHCPS_ADDRESS_OFFERRED;
dhcps->leasearr[idx].proposed_leasetime = client_lease_time;
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("add_client_entry: Adding Client Entry at Index = %"U32_F"\n", idx));
}
LWIP_STATIC int find_free_slot(struct dhcps *dhcps)
{
int i;
for (i = 0; i < dhcps->lease_num; i++) {
if ((dhcps->leasearr[i].flags == DHCPS_ADDRESS_FREE) &&
(htonl(dhcps->start_addr.addr + (u32_t)i) != ip_2_ip4(&dhcps->netif->ip_addr)->addr)) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("find_free_slot: Found Free Slot at Index = %"U32_F"\n", i));
return i;
}
}
return -1;
}
LWIP_STATIC struct dyn_lease_addr *find_client_lease(struct dhcps *dhcps, struct dhcp_msg *client_msg)
{
int i;
for (i = 0; i < dhcps->lease_num; i++) {
if (dhcps->leasearr[i].flags != DHCPS_ADDRESS_FREE) {
if (memcmp(dhcps->leasearr[i].cli_hwaddr, client_msg->chaddr, client_msg->hlen) == 0) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("find_client_lease: Found Client Lease at Index = %"U32_F"\n", i));
return &(dhcps->leasearr[i]);
}
}
}
return NULL;
}
LWIP_STATIC ip4_addr_t validate_discover(struct dhcps *dhcps, struct dhcp_msg *client_msg,
struct dyn_lease_addr **client_lease)
{
ip4_addr_t client_ip;
int idx = -1;
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("validate_discover: Validating Discover Message\n"));
client_ip.addr = 0;
if (*client_lease == NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("validate_discover: Existing Client Lease not Found\n"));
if (dhcps_option_given(dhcps, DHCP_OPTION_IDX_REQUESTED_IP)) {
client_ip.addr = (u32_t)dhcps_get_option_value(dhcps, DHCP_OPTION_IDX_REQUESTED_IP);
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_discover function: Requested IP from client = %"U32_F"\n", client_ip.addr));
#endif
if ((client_ip.addr >= dhcps->start_addr.addr) && (client_ip.addr <= dhcps->end_addr.addr)) {
idx = (int)(client_ip.addr - dhcps->start_addr.addr);
if ((dhcps->leasearr[idx].flags != DHCPS_ADDRESS_FREE) ||
(ntohl(client_ip.addr) == ip_2_ip4(&dhcps->netif->ip_addr)->addr)) {
/* Requested IP is not available */
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_discover function: Requested IP from client = %"U32_F" Not available \n", client_ip.addr));
#endif
idx = -1;
}
}
}
if (idx == -1) {
idx = find_free_slot(dhcps);
if (idx == -1) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_discover function: No Free Slot available for Storing addresses\n"));
client_ip.addr = 0;
return client_ip;
}
client_ip.addr = dhcps->start_addr.addr + (u32_t)idx;
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_discover function: New IP = %"U32_F" is being assigned\n", client_ip.addr));
#endif
}
add_client_entry(dhcps, (unsigned int)idx, client_msg);
(*client_lease) = &(dhcps->leasearr[idx]);
} else {
client_ip.addr = (*client_lease)->cli_addr.addr;
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_discover: Existing Client Lease Found. Existing IP =%"U32_F"\n", client_ip.addr));
#endif
if ((dhcps_option_given(dhcps, DHCP_OPTION_IDX_LEASE_TIME))
#if (~0 != LWIP_DHCPS_LEASE_TIME)
&& (dhcps_get_option_value(dhcps, DHCP_OPTION_IDX_LEASE_TIME) < LWIP_DHCPS_LEASE_TIME)
#endif
) {
/* Assign the newly requested time or else use the existing lease time as-is */
(*client_lease)->proposed_leasetime = (u32_t)dhcps_get_option_value(dhcps, DHCP_OPTION_IDX_LEASE_TIME);
}
}
return client_ip;
}
void dhcp_common_option(struct dhcp_msg *msg_out, u8_t option_type, u8_t option_len, u16_t *options_out_len)
{
*options_out_len = dhcp_option(*options_out_len, msg_out->options, option_type, option_len);
}
void dhcp_common_option_byte(struct dhcp_msg *msg_out, u8_t value, u16_t *options_out_len)
{
*options_out_len = dhcp_option_byte(*options_out_len, msg_out->options, value);
}
void dhcp_common_option_long(struct dhcp_msg *msg_out, u32_t value, u16_t *options_out_len)
{
*options_out_len = dhcp_option_long(*options_out_len, msg_out->options, value);
}
void dhcp_common_option_trailer(struct dhcp_msg *msg_out, u16_t options_out_len, struct pbuf *p_out)
{
dhcp_option_trailer(options_out_len, msg_out->options, p_out);
}
LWIP_STATIC void handle_discover(struct netif *netif, struct dhcps *dhcps,
struct dhcp_msg *client_msg, struct dyn_lease_addr *client_lease)
{
#if !LWIP_DHCPS_DISCOVER_BROADCAST
ip_addr_t client_ipaddr;
#endif
ip4_addr_t client_ip;
ip_addr_t dst_addr;
struct pbuf *out_msg = NULL;
struct dhcp_msg *srvr_msg = NULL;
u16_t options_len = 0;
#if !LWIP_DHCPS_DISCOVER_BROADCAST
#if ETHARP_SUPPORT_STATIC_ENTRIES
struct eth_addr ethaddr;
#endif
#endif
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_discover: Processing Discover Message\n"));
client_ip = validate_discover(dhcps, client_msg, &client_lease);
if (client_ip.addr == 0) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_discover: Returning as unable to get a proper address for client\n"));
return;
}
out_msg = dhcps_create_base_msg(client_msg);
if (out_msg == NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_discover function: Memory allocation for base message failed\n"));
return;
}
srvr_msg = (struct dhcp_msg *)out_msg->payload;
// no need check msg pointer from payload here
srvr_msg->yiaddr.addr = htonl(client_ip.addr);
dhcp_common_option(srvr_msg, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN, &options_len);
dhcp_common_option_byte(srvr_msg, DHCP_OFFER, &options_len);
/* hilink need this router option */
dhcp_common_option(srvr_msg, DHCP_OPTION_ROUTER, DHCP_OPTION_ROUTER_SIZE, &options_len);
dhcp_common_option_long(srvr_msg, ntohl(ip_2_ip4(&netif->ip_addr)->addr), &options_len);
/* netif already holds the Server ID in network order. so, no need to convert it again */
dhcp_common_option(srvr_msg, DHCP_OPTION_SERVER_ID, DHCP_OPTION_SERVER_ID_LEN, &options_len);
dhcp_common_option_long(srvr_msg, ntohl(ip_2_ip4(&netif->ip_addr)->addr), &options_len);
dhcp_common_option(srvr_msg, DHCP_OPTION_LEASE_TIME, DHCP_OPTION_LEASE_TIME_SIZE, &options_len);
dhcp_common_option_long(srvr_msg, client_lease->proposed_leasetime, &options_len);
dhcp_common_option(srvr_msg, DHCP_OPTION_T1, DHCP_OPTION_T1_LEN, &options_len);
dhcp_common_option_long(srvr_msg, (client_lease->proposed_leasetime / 2), &options_len);
dhcp_common_option(srvr_msg, DHCP_OPTION_T2, DHCP_OPTION_T2_LEN, &options_len);
/* calculate safe periods for lease (proposed_leasetime * 0.875 -> 87.5%) */
dhcp_common_option_long(srvr_msg, ((client_lease->proposed_leasetime * 7) / 8), &options_len);
/* No need to convert netmask into network order as it is already stored in network order */
dhcp_common_option(srvr_msg, DHCP_OPTION_SUBNET_MASK, DHCP_OPTION_SUBNET_MASK_SIZE, &options_len);
dhcp_common_option_long(srvr_msg, ntohl(ip4_addr_get_u32(ip_2_ip4(&netif->netmask))), &options_len);
dhcp_common_option_trailer(srvr_msg, options_len, out_msg);
if (client_msg->ciaddr.addr != 0) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_discover: sendto(OFFER, ciaddr, DHCP_CLIENT_PORT)\n"));
ip_addr_set_ip4_u32_val(dst_addr, (u32_t)(client_msg->ciaddr.addr));
(void)udp_sendto_if_src(dhcps->pcb, out_msg, &dst_addr, DHCP_CLIENT_PORT, netif, &(netif->ip_addr));
}
#if !LWIP_DHCPS_DISCOVER_BROADCAST
else if (ntohs(client_msg->flags) & DHCP_BROADCAST_FLAG) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_discover: sendto(OFFER, IP_ADDR_BROADCAST, DHCP_CLIENT_PORT)\n"));
(void)udp_sendto_if_src(dhcps->pcb, out_msg, IP_ADDR_BROADCAST, DHCP_CLIENT_PORT, netif, &(netif->ip_addr));
} else {
client_ip.addr = htonl(client_ip.addr);
#if ETHARP_SUPPORT_STATIC_ENTRIES
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_discover: Updating ARP Static Entry for unicast reply\n"));
if (memcpy_s(ethaddr.addr, ETHARP_HWADDR_LEN, client_msg->chaddr, client_msg->hlen) != EOK) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("memcpy_s failed\n"));
(void)pbuf_free(out_msg);
return;
}
if (etharp_add_static_entry(&client_ip, &ethaddr) != ERR_OK) {
(void)pbuf_free(out_msg);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_discover: Adding static entry to arp cache failed\n"));
return;
}
#endif
/* Need to check and add an arp entry to make this pass through smoothly */
ip_addr_copy_from_ip4(client_ipaddr, client_ip);
(void)udp_sendto_if_src(dhcps->pcb, out_msg, &client_ipaddr, DHCP_CLIENT_PORT, netif, &(netif->ip_addr));
#if ETHARP_SUPPORT_STATIC_ENTRIES
/* We just added the entry above and checked for it's success too. so, the below function call cannot fail */
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_discover: Removing ARP Static Entry added for unicast reply\n"));
(void)etharp_remove_static_entry(&client_ip);
#endif
}
#else
else {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_discover: sendto(OFFER, IP_ADDR_BROADCAST, DHCP_CLIENT_PORT)\n"));
(void)udp_sendto_if_src(dhcps->pcb, out_msg, IP_ADDR_BROADCAST, DHCP_CLIENT_PORT, netif, &(netif->ip_addr));
}
#endif
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_discover: deleting()ing\n"));
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_discover: Sending Reply has been successful\n"));
(void)pbuf_free(out_msg);
return;
}
LWIP_STATIC ip4_addr_t validate_request_message(struct netif *netif, struct dhcp_msg *client_msg,
struct dyn_lease_addr *client_lease, ip4_addr_t serverid)
{
struct dhcps *dhcps = netif_get_dhcps(netif);
ip4_addr_t requested_ip;
requested_ip.addr = 0;
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("validate_request_message: Processing Request Message\n"));
if ((client_lease != NULL) && (client_lease->flags == DHCPS_ADDRESS_OFFERRED)) {
/* Now, we are in selecting state */
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("validate_request_message: In Selecting State\n"));
if ((serverid.addr == 0) || (client_msg->ciaddr.addr != 0) ||
(!dhcps_option_given(dhcps, DHCP_OPTION_IDX_REQUESTED_IP))) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("Server ID or ciaddr or requested ip option is not present\n"));
return requested_ip;
}
if (serverid.addr != ip_2_ip4(&netif->ip_addr)->addr) {
/* This message is not meant for us. The client intends to talk to some other server */
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_request_message: Server id doesn't match with ours. Message not for us\n"));
requested_ip.addr = 1;
return requested_ip;
}
requested_ip.addr = (u32_t)dhcps_get_option_value(dhcps, DHCP_OPTION_IDX_REQUESTED_IP);
} else {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_request_message: In Init-Reboot, Renew or Rebinding State\n"));
/* Now, we can be either in Init-reboot state or renew state or rebinding state */
if (dhcps_option_given(dhcps, DHCP_OPTION_IDX_REQUESTED_IP)) {
/* Requested IP option is filled in. Indicates we are mostly in Init-Reboot State */
if (client_lease == NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_request_message: No Configuration found corresponding to request message\n"));
requested_ip.addr = 1;
return requested_ip;
}
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_request_message: Requested IP Option is present. So, considering as Init-Reboot State\n"));
if (client_msg->ciaddr.addr != 0) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_request_message: Error: ciaddr is filled in the Init-Reboot state. \n"));
return requested_ip;
}
requested_ip.addr = (u32_t)dhcps_get_option_value(dhcps, DHCP_OPTION_IDX_REQUESTED_IP);
} else {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("validate_request_message: \
Requested IP Option is not present. So, considering as Renewing or Rebinding State\n"));
if (client_msg->ciaddr.addr == 0) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("validate_request_message: Error: ciaddr is not filled in the Renewing or Rebinding state. \n"));
return requested_ip;
}
requested_ip.addr = ntohl(client_msg->ciaddr.addr);
}
}
/* requested_ip is in host order and DHCP Server IP is in network order,
so converting the former to network order for check */
if (htonl(requested_ip.addr) == ip_2_ip4(&netif->ip_addr)->addr) {
/* This requested_ip is the dhcp server is using, it is invalid */
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("validate_request_message: Requested IP addr is invalid\n"));
requested_ip.addr = 1;
}
return requested_ip;
}
LWIP_STATIC void handle_request(struct netif *netif, struct dhcps *dhcps, struct dhcp_msg *client_msg,
struct dyn_lease_addr *client_lease, ip4_addr_t serverid)
{
ip4_addr_t requested_ip;
struct pbuf *out_msg = NULL;
struct dhcp_msg *srvr_msg = NULL;
u16_t options_len = 0;
ip_addr_t dst_addr;
ip_addr_t ip_send;
#if ETHARP_SUPPORT_STATIC_ENTRIES
struct eth_addr ethaddr;
#endif
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_request: Processing Request Message\n"));
requested_ip = validate_request_message(netif, client_msg, client_lease, serverid);
if (requested_ip.addr == 1) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_request: Validation of request message failed. Dropping the packet.\n"));
return;
}
out_msg = dhcps_create_base_msg(client_msg);
if (out_msg == NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_request: Creating base message failed\n"));
return;
}
srvr_msg = (struct dhcp_msg *)out_msg->payload;
dhcp_common_option(srvr_msg, DHCP_OPTION_SERVER_ID, DHCP_OPTION_SERVER_ID_LEN, &options_len);
dhcp_common_option_long(srvr_msg, ntohl(ip_2_ip4(&netif->ip_addr)->addr), &options_len);
/* hilink need this router option */
dhcp_common_option(srvr_msg, DHCP_OPTION_ROUTER, DHCP_OPTION_ROUTER_SIZE, &options_len);
dhcp_common_option_long(srvr_msg, ntohl(ip_2_ip4(&netif->ip_addr)->addr), &options_len);
if ((client_lease != NULL) && (client_lease->cli_addr.addr == requested_ip.addr)) {
if (client_lease->proposed_leasetime != (u32_t)(~0)) {
if (client_lease->flags == DHCPS_ADDRESS_OFFERRED) {
client_lease->leasetime = sys_now() + (client_lease->proposed_leasetime * 1000);
} else {
client_lease->leasetime += (client_lease->proposed_leasetime * 1000);
}
} else {
client_lease->leasetime = client_lease->proposed_leasetime;
}
client_lease->flags = DHCPS_ADDRESS_BOUND;
srvr_msg->yiaddr.addr = htonl(client_lease->cli_addr.addr);
dhcp_common_option(srvr_msg, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN, &options_len);
dhcp_common_option_byte(srvr_msg, DHCP_ACK, &options_len);
dhcp_common_option(srvr_msg, DHCP_OPTION_LEASE_TIME, DHCP_OPTION_LEASE_TIME_SIZE, &options_len);
dhcp_common_option_long(srvr_msg, client_lease->proposed_leasetime, &options_len);
dhcp_common_option(srvr_msg, DHCP_OPTION_T1, DHCP_OPTION_T1_LEN, &options_len);
dhcp_common_option_long(srvr_msg, (client_lease->proposed_leasetime / 2), &options_len);
dhcp_common_option(srvr_msg, DHCP_OPTION_T2, DHCP_OPTION_T2_LEN, &options_len);
/* calculate safe periods for lease (proposed_leasetime * 0.875 -> 87.5%) */
dhcp_common_option_long(srvr_msg, ((client_lease->proposed_leasetime * 7) / 8), &options_len);
dhcp_common_option(srvr_msg, DHCP_OPTION_SUBNET_MASK, DHCP_OPTION_SUBNET_MASK_SIZE, &options_len);
dhcp_common_option_long(srvr_msg, ntohl(ip_2_ip4(&netif->netmask)->addr), &options_len);
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_request: Send ACK. to=%"U32_F" lease time=%"U32_F"\n",
requested_ip.addr, client_lease->proposed_leasetime));
#endif
} else {
dhcp_common_option(srvr_msg, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN, &options_len);
dhcp_common_option_byte(srvr_msg, DHCP_NAK, &options_len);
/* Just set this here, so that the NAK message is brcasted.
The correct flags has already been added in the respose message during base message creation */
client_msg->flags |= htons(DHCP_BROADCAST_FLAG);
client_msg->ciaddr.addr = 0; /* This is done so that NAK Gets brcasted */
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_request: Send NAK. Requested from=%"U32_F"\n", requested_ip.addr));
#endif
}
requested_ip.addr = htonl(requested_ip.addr);
dhcp_common_option_trailer(srvr_msg, options_len, out_msg);
if (client_msg->ciaddr.addr != 0) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_request: sendto(ACK, ciaddr, DHCP_CLIENT_PORT)\n"));
ip_addr_set_ip4_u32_val(dst_addr, (u32_t)(client_msg->ciaddr.addr));
(void)udp_sendto_if_src(dhcps->pcb, out_msg, &dst_addr, DHCP_CLIENT_PORT, netif, &(netif->ip_addr));
} else if (ntohs(client_msg->flags) & DHCP_BROADCAST_FLAG) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_request: sending reply using brdcast \n"));
(void)udp_sendto_if_src(dhcps->pcb, out_msg, IP_ADDR_BROADCAST, DHCP_CLIENT_PORT, netif, &(netif->ip_addr));
} else {
#if ETHARP_SUPPORT_STATIC_ENTRIES
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_request: Updating ARP Static Entry for unicast reply\n"));
if (memcpy_s(ethaddr.addr, ETHARP_HWADDR_LEN, client_msg->chaddr, client_msg->hlen) != EOK) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_request: Copy chaddr failed\n"));
(void)pbuf_free(out_msg);
return;
}
if (ERR_OK != etharp_add_static_entry(&requested_ip, &ethaddr)) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_request: Adding static entry to arp cache failed\n"));
(void)pbuf_free(out_msg);
return;
}
#endif
/* Need to check and add an arp entry to make this pass through smoothly */
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_request: sending reply using unicast Client IP =%"U32_F"\n", requested_ip.addr));
#endif
ip_send.u_addr.ip4.addr = requested_ip.addr;
ip_send.type = IPADDR_TYPE_V4;
(void)udp_sendto_if_src(dhcps->pcb, out_msg, &ip_send, DHCP_CLIENT_PORT, netif, &(netif->ip_addr));
#if ETHARP_SUPPORT_STATIC_ENTRIES
/* We just added the entry above and checked for it's success too. so, the below function call cannot fail */
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_request: Removing ARP Static Entry added for unicast reply\n"));
(void)etharp_remove_static_entry(&requested_ip);
#endif
}
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_request: deleting\n"));
(void)pbuf_free(out_msg);
return;
}
LWIP_STATIC void handle_decline(struct netif *netif, struct dhcps *dhcps, struct dhcp_msg *client_msg,
struct dyn_lease_addr *client_lease)
{
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_decline: Processing Decline Message\n"));
if ((client_lease != NULL) && (dhcps_option_given(dhcps, DHCP_OPTION_IDX_REQUESTED_IP)) &&
(client_msg->ciaddr.addr == 0)) {
if (client_lease->cli_addr.addr == (u32_t)dhcps_get_option_value(dhcps, DHCP_OPTION_IDX_REQUESTED_IP)) {
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_decline: Marking Client Entry as declined. Client IP =%"U32_F"\n",
client_lease->cli_addr.addr));
#endif
(void)memset_s(client_lease->cli_hwaddr, sizeof(client_lease->cli_hwaddr), 0, DHCP_CHADDR_LEN);
client_lease->proposed_leasetime = 0;
client_lease->leasetime = sys_now() + (LWIP_DHCPS_DECLINE_TIME * 1000);
client_lease->flags = DHCPS_ADDRESS_DECLINED;
}
}
}
LWIP_STATIC void handle_inform(struct netif *netif, struct dhcps *dhcps, struct dhcp_msg *client_msg)
{
struct pbuf *out_msg = NULL;
struct dhcp_msg *srvr_msg = NULL;
u16_t options_len = 0;
ip_addr_t dst_addr;
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_inform: Processing Inform Message\n"));
if (client_msg->ciaddr.addr == 0) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_inform: ciaddr is empty. Can't send back a response\n"));
return;
}
out_msg = dhcps_create_base_msg(client_msg);
if (out_msg == NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_inform: Creating base message failed\n"));
return;
}
srvr_msg = (struct dhcp_msg *)out_msg->payload;
dhcp_common_option(srvr_msg, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN, &options_len);
dhcp_common_option_byte(srvr_msg, DHCP_ACK, &options_len);
dhcp_common_option_trailer(srvr_msg, options_len, out_msg);
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("handle_inform: Send ACK to Client. Client is=%"U32_F"\n", client_msg->ciaddr.addr));
#endif
ip_addr_set_ip4_u32_val(dst_addr, client_msg->ciaddr.addr);
(void)udp_sendto_if_src(dhcps->pcb, out_msg, &dst_addr, DHCP_CLIENT_PORT, netif, &(netif->ip_addr));
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("handle_inform: deleting pbuf\n"));
(void)pbuf_free(out_msg);
return;
}
LWIP_STATIC void handle_client_messages(struct netif *netif, struct dhcps *dhcps,
struct dhcp_msg *client_msg, ip4_addr_t serverid, u8_t msg_type)
{
struct dyn_lease_addr *client_lease = NULL;
client_lease = find_client_lease(dhcps, client_msg);
switch (msg_type) {
case DHCP_DISCOVER:
handle_discover(netif, dhcps, client_msg, client_lease);
break;
case DHCP_REQUEST:
handle_request(netif, dhcps, client_msg, client_lease, serverid);
break;
case DHCP_DECLINE:
handle_decline(netif, dhcps, client_msg, client_lease);
break;
case DHCP_RELEASE:
if ((client_lease != NULL) && (client_lease->cli_addr.addr == ntohl(client_msg->ciaddr.addr))) {
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP Release: Client IPAdd =%"U32_F"\n", client_msg->ciaddr.addr));
#endif
(void)memset_s(client_lease, sizeof(struct dyn_lease_addr), 0, sizeof(struct dyn_lease_addr));
client_lease->flags = DHCPS_ADDRESS_FREE;
}
break;
case DHCP_INFORM:
handle_inform(netif, dhcps, client_msg);
break;
default:
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("DHCP Server. Invalid message type received %d\n", msg_type));
}
}
err_t dhcps_parse_options(struct pbuf *p, struct dhcps *dhcps)
{
return dhcp_parse_reply(p, &dhcps->dhcp);
}
LWIP_STATIC void dhcps_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *ip_addr, u16_t port)
{
struct netif *netif = (struct netif *)arg;
struct dhcps *dhcps = netif_get_dhcps(netif);
struct dhcp_msg *client_msg = (struct dhcp_msg *)p->payload;
u8_t msg_type;
ip4_addr_t serverid;
ip4_addr_t addr;
if (client_msg == NULL) {
return;
}
addr.addr = ip_addr->u_addr.ip4.addr;
serverid.addr = 0;
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("dhcps_recv(pbuf = %p) from DHCP Client %"U16_F".%"U16_F".%"U16_F".%"U16_F" port %"U16_F"\n", (void*)p,
ip4_addr1_16(&addr), ip4_addr2_16(&addr), ip4_addr3_16(&addr), ip4_addr4_16(&addr), port));
#endif
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("pbuf->len = %"U16_F"\n", p->len));
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("pbuf->tot_len = %"U16_F"\n", p->tot_len));
/* prevent warnings about unused arguments */
LWIP_UNUSED_ARG(pcb);
LWIP_UNUSED_ARG(addr);
LWIP_UNUSED_ARG(port);
dhcps_clear_all_options(dhcps);
/* Check and remove old entries on each call to dhcp_recv. This way, we don't need to maintain timers */
remove_stale_entries(dhcps);
if (p->len < DHCP_OPTIONS_OFS) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("DHCP client message or pbuf too short. pbuf len =%"U16_F" DHCP MIN Reply Len = %"U32_F"\n",
p->len, DHCP_MIN_REPLY_LEN));
goto free_pbuf_and_return;
}
if (client_msg->op != DHCP_BOOTREQUEST) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("Not a DHCP reply message, Type %"U16_F"\n", (u16_t)client_msg->op));
goto free_pbuf_and_return;
}
if (client_msg->cookie != PP_HTONL(DHCP_MAGIC_COOKIE)) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("DHCP Server. Cookie Value is incorrect. %"U32_F"\n", (u32_t)client_msg->cookie));
goto free_pbuf_and_return;
}
if (client_msg->hlen != ETHARP_HWADDR_LEN) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("DHCP Server. Invalid hardware address length %"U16_F"\n", (u16_t)client_msg->hlen));
goto free_pbuf_and_return;
}
if (dhcps_parse_options(p, dhcps) != ERR_OK) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("Parsing of Options failed in DHCP Client Message\n"));
goto free_pbuf_and_return;
}
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("Searching DHCP_OPTION_MESSAGE_TYPE\n"));
/* obtain pointer to DHCP message type */
if (!dhcps_option_given(dhcps, DHCP_OPTION_IDX_MSG_TYPE)) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("DHCP_OPTION_MESSAGE_TYPE option not found\n"));
goto free_pbuf_and_return;
}
/* read DHCP message type */
msg_type = (u8_t)dhcps_get_option_value(dhcps, DHCP_OPTION_IDX_MSG_TYPE);
if (dhcps_option_given(dhcps, DHCP_OPTION_IDX_SERVER_ID)) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("DHCP_OPTION_SERVER_ID option found\n"));
/* Parse options would have changed it to host order. But, we have our IP stored in netif in network order */
serverid.addr = htonl((u32_t)dhcps_get_option_value(dhcps, DHCP_OPTION_IDX_SERVER_ID));
}
if ((serverid.addr != 0) && ((msg_type == DHCP_DISCOVER) || (msg_type == DHCP_INFORM))) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("Serverid present in DHCP_DISCOVER and DHCP_INFORM messages\n"));
goto free_pbuf_and_return;
}
if ((!ip4_addr_cmp(&serverid, ip_2_ip4(&netif->ip_addr))) &&
((msg_type == DHCP_DECLINE) || (msg_type == DHCP_RELEASE))) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("Serverid not present in DHCP_RELEASE and DHCP_DECLINE messages\n"));
goto free_pbuf_and_return;
}
handle_client_messages(netif, dhcps, client_msg, serverid, msg_type);
free_pbuf_and_return:
(void)pbuf_free(p);
}
err_t dhcps_start(struct netif *netif, const char *start_ip, u16_t ip_num)
{
struct dhcps *dhcps = NULL;
ip4_addr_t address_in_hton;
int err;
LWIP_ERROR("netif != NULL", (netif != NULL), return ERR_ARG);
dhcps = netif_get_dhcps(netif);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("dhcps_start(netif=%p) %s\n", (void *)netif, netif_get_name(netif)));
if (netif->mtu < DHCP_MAX_MSG_LEN_MIN_REQUIRED) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("MTU =%"U16_F",DHCP Msg Len Required =%"U32_F"\n", netif->mtu, DHCP_MAX_MSG_LEN_MIN_REQUIRED));
return ERR_MEM;
}
if (dhcps != NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcps_start(): DHCP Server is already started\n"));
return ERR_MEM;
}
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcps_start(): starting new DHCP Server\n"));
dhcps = (struct dhcps *)mem_malloc(sizeof(struct dhcps));
if (dhcps == NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcps_start(): could not allocate dhcp\n"));
return ERR_MEM;
}
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcps_start(): allocated dhcp"));
(void)memset_s(dhcps, sizeof(struct dhcps), 0, sizeof(struct dhcps));
dhcps->pcb = udp_new();
if (dhcps->pcb == NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): could not allocate pcb\n"));
mem_free((void *)dhcps);
return ERR_MEM;
}
#if LWIP_SO_BINDTODEVICE
/* bind dhcp udp_pcb to specific netif, this could make dhcp server start on multiple netif */
dhcps->pcb->ifindex = netif->ifindex;
#endif
if ((start_ip == NULL) || (ip_num == 0)) {
/* use default ip lease configuration. */
dhcps->start_addr.addr = ntohl(ip_2_ip4(&netif->ip_addr)->addr & ip_2_ip4(&netif->netmask)->addr) + 1;
dhcps->end_addr.addr = ntohl(ip_2_ip4(&netif->ip_addr)->addr | (~ip_2_ip4(&netif->netmask)->addr)) - 1;
dhcps->lease_num = (u8_t)(dhcps->end_addr.addr - dhcps->start_addr.addr + 1);
if (dhcps->lease_num > LWIP_DHCPS_MAX_LEASE) {
dhcps->lease_num = LWIP_DHCPS_MAX_LEASE;
dhcps->end_addr.addr = dhcps->start_addr.addr + LWIP_DHCPS_MAX_LEASE - 1;
}
} else {
dhcps->start_addr.addr = ntohl(ipaddr_addr(start_ip));
dhcps->end_addr.addr = (u32_t)(dhcps->start_addr.addr +
(u32_t)(LWIP_MIN(ip_num - 1, LWIP_DHCPS_MAX_LEASE - 1)));
ip4_addr_set_hton(&address_in_hton, &dhcps->start_addr);
if (!ip4_addr_netcmp((&address_in_hton), ip_2_ip4(&netif->ip_addr), ip_2_ip4(&netif->netmask)) ||
ip4_addr_isbroadcast((&address_in_hton), netif)) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): %s in not a valid ip lease\n", start_ip));
udp_remove(dhcps->pcb);
mem_free((void *)dhcps);
return ERR_ARG;
}
ip4_addr_set_hton(&address_in_hton, &dhcps->end_addr);
if (!ip4_addr_netcmp((&address_in_hton), ip_2_ip4(&netif->ip_addr), ip_2_ip4(&netif->netmask)) ||
ip4_addr_isbroadcast((&address_in_hton), netif)) {
dhcps->end_addr.addr = ntohl(ip_2_ip4(&netif->ip_addr)->addr | (~ip_2_ip4(&netif->netmask)->addr)) - 1;
}
dhcps->lease_num = (u8_t)(dhcps->end_addr.addr - dhcps->start_addr.addr + 1);
}
dhcps->netif = netif;
dhcps->pcb->so_options |= SOF_BROADCAST;
err = udp_bind(dhcps->pcb, IP_ADDR_ANY, DHCP_SERVER_PORT);
if (err != ERR_OK) {
udp_remove(dhcps->pcb);
mem_free((void *)dhcps);
return ERR_MEM;
}
err = udp_connect(dhcps->pcb, IP_ADDR_ANY, DHCP_CLIENT_PORT);
if (err != ERR_OK) {
udp_remove(dhcps->pcb);
mem_free((void *)dhcps);
return ERR_MEM;
}
udp_recv(dhcps->pcb, dhcps_recv, netif);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcps_start(): starting DHCPS Successfully\n"));
#ifdef LWIP_DEV_DEBUG
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("dhcps_start(): DHCPS Conf:: netif addr = %"U32_F" dhcps start addr%"U32_F" dhcp end addr%"U32_F"\n",
ip_2_ip4(&netif->ip_addr)->addr, dhcps->start_addr.addr, dhcps->end_addr.addr));
#endif
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE,
("dhcps_start(): DHCPS Lease Conf:: Lease Time = %"U32_F" Offer Time = %"U32_F"\n",
LWIP_DHCPS_LEASE_TIME, LWIP_DHCPS_OFFER_TIME));
netif_set_dhcps(netif, dhcps);
return ERR_OK;
}
void dhcps_stop(struct netif *netif)
{
LWIP_ERROR("dhcps_stop: netif != NULL", (netif != NULL), return);
struct dhcps *dhcps = netif_get_dhcps(netif);
if (dhcps != NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcps_stop(): Stopping DHCP Server\n"));
if (dhcps->pcb != NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcps_stop(): Removing UDP PCB\n"));
udp_remove(dhcps->pcb);
dhcps->pcb = NULL;
}
mem_free(dhcps);
netif_set_dhcps(netif, NULL);
}
}
#endif

137
net/lwip-2.1/enhancement/src/api_shell_fix.c → net/lwip-2.1/enhancement/src/fixme.c
View File

@ -29,46 +29,26 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "api_shell_fix.h"
#include <time.h>
#include "lwip/fixme.h"
#include <lwip/sys.h>
#include <lwip/snmp.h>
#include <lwip/etharp.h>
#include <lwip/netifapi.h>
#include <lwip/sockets.h>
#include <lwip/priv/api_msg.h>
#include "securec.h"
#define NETIFAPI_VAR_REF(name) API_VAR_REF(name)
#define NETIFAPI_VAR_DECLARE(name) API_VAR_DECLARE(struct netifapi_msg, name)
#define NETIFAPI_VAR_ALLOC(name) API_VAR_ALLOC(struct netifapi_msg, MEMP_NETIFAPI_MSG, name, ERR_MEM)
#define NETIFAPI_VAR_FREE(name) API_VAR_FREE(MEMP_NETIFAPI_MSG, name)
/**
*
*
* ################# FOR API_SHELL ONLY #################
*
*
*
*/
#if LWIP_ENABLE_LOS_SHELL_CMD
#if LWIP_DHCP
#include <lwip/dhcp.h>
/*
* Close DHCP and set static network.
*
* @param netif a pre-allocated netif structure
*
* @return ERR_OK, or ERR_VAL if failed.
*/
err_t netif_dhcp_off(struct netif *netif)
@ -85,32 +65,48 @@ err_t netif_dhcp_off(struct netif *netif)
old_gateway = netif->gw;
if (netif_dhcp_data(netif)) {
(void) dhcp_release(netif);
(void) dhcp_stop(netif);
(void) dhcp_cleanup(netif);
(void)dhcp_release(netif);
(void)dhcp_stop(netif);
(void)dhcp_cleanup(netif);
LWIP_DEBUGF(NETIF_DEBUG, ("DHCP is close;set static IP\n"));
}
ip_addr_set_val(&netif->ip_addr, &old_ipaddr);
ip_addr_set_val(&netif->netmask, &old_netmask);
ip_addr_set_val(&netif->gw, &old_gateway);
(void) netif_set_up(netif);
(void)netif_set_up(netif);
return ERR_OK;
}
err_t dhcp_is_bound(struct netif *netif)
{
struct dhcp *dhcp = NULL;
LWIP_ERROR("netif != NULL", (netif != NULL), return ERR_ARG);
dhcp = netif_dhcp_data(netif);
LWIP_ERROR("netif->dhcp != NULL", (dhcp != NULL), return ERR_ARG);
if (dhcp->state == DHCP_STATE_BOUND) {
return ERR_OK;
} else {
return ERR_INPROGRESS;
}
}
#endif /* LWIP_DHCP */
#if LWIP_DHCPS
#include "dhcps.h"
#include "lwip/dhcps.h"
static err_t netifapi_do_dhcps_start (struct tcpip_api_call_data *m)
static err_t netifapi_do_dhcps_start(struct tcpip_api_call_data *m)
{
/* cast through void* to silence alignment warnings.
* We know it works because the structs have been instantiated as struct netifapi_msg */
err_t ret;
struct netifapi_msg *msg = (struct netifapi_msg*)(void*)m;
struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m;
ret = dhcps_start(msg->netif, msg->msg.dhcp_start_params.start_ip, msg->msg.dhcp_start_params.ip_num);
return ret;
}
@ -124,8 +120,8 @@ err_t netifapi_dhcps_start(struct netif *netif, char *start_ip, u16_t ip_num)
NETIFAPI_VAR_ALLOC(msg);
NETIFAPI_VAR_REF(msg).netif = netif;
NETIFAPI_VAR_REF(msg).msg.dhcp_start_params.start_ip = start_ip ;
NETIFAPI_VAR_REF(msg).msg.dhcp_start_params.ip_num = ip_num ;
NETIFAPI_VAR_REF(msg).msg.dhcp_start_params.start_ip = start_ip;
NETIFAPI_VAR_REF(msg).msg.dhcp_start_params.ip_num = ip_num;
err = tcpip_api_call(netifapi_do_dhcps_start, &API_VAR_REF(msg).call);
@ -216,19 +212,19 @@ static struct netif *netif_find_by_name(const char *name)
return NULL;
}
if (strcmp("lo", name) == 0) {
LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: found %c%c\n", name[0], name[1]));
return netif_find(name);
}
NETIF_FOREACH(netif) {
if (strcmp("lo", name) == 0 && (netif->name[0] == 'l' && netif->name[1] == 'o')) {
LWIP_DEBUGF(NETIF_DEBUG, ("netif_find_by_name: found lo\n"));
return netif;
}
if (strcmp(netif->full_name, name) == 0) {
LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: found %c%c\n", name[0], name[1]));
LWIP_DEBUGF(NETIF_DEBUG, ("netif_find_by_name: found %s\n", name));
return netif;
}
}
LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: didn't find %c%c\n", name[0], name[1]));
LWIP_DEBUGF(NETIF_DEBUG, ("netif_find_by_name: didn't find %s\n", name));
return NULL;
}
@ -294,7 +290,7 @@ err_t netif_set_mtu(struct netif *netif, u16_t netif_mtu)
#endif /* LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES */
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif: MTU of interface %s is changed to %d\n",
netif_get_name(netif), netif->mtu));
netif_get_name(netif), netif->mtu));
return ERR_OK;
}
@ -322,31 +318,35 @@ err_t netif_set_hwaddr(struct netif *netif, const unsigned char *hw_addr, int hw
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("netif: HW address of interface %s set to %02X:%02X:%02X:%02X:%02X:%02X\n",
netif_get_name(netif),
netif->hwaddr[0], netif->hwaddr[1], netif->hwaddr[2],
netif->hwaddr[3], netif->hwaddr[4], netif->hwaddr[5]));
netif_get_name(netif),
netif->hwaddr[0], netif->hwaddr[1], netif->hwaddr[2],
netif->hwaddr[3], netif->hwaddr[4], netif->hwaddr[5]));
return ERR_OK;
}
err_t etharp_update_arp_entry(struct netif *netif, const ip4_addr_t *ipaddr, struct eth_addr *ethaddr, u8_t flags)
{
// FIXME
return 0;
}
err_t etharp_delete_arp_entry(struct netif *netif, ip4_addr_t *ipaddr)
{
// FIXME
return 0;
}
err_t lwip_dns_setserver(u8_t numdns, ip_addr_t *dnsserver)
{
// FIXME
return 0;
}
err_t lwip_dns_getserver(u8_t numdns, ip_addr_t *dnsserver)
{
// FIXME
return 0;
}
@ -354,57 +354,42 @@ err_t lwip_dns_getserver(u8_t numdns, ip_addr_t *dnsserver)
struct raw_pcb *pkt_raw_pcbs;
#endif
struct raw_pcb *raw_pcbs;
#if LWIP_RAW
struct raw_pcb *raw_pcbs; /* already defined in raw.c, but is static */
#endif
/******************************************************************/
#if LWIP_ENABLE_IP_CONFLICT_SIGNAL
u32_t is_ip_conflict_signal = 0;
sys_sem_t ip_conflict_detect;
#endif
u32_t is_dup_detect_initialized = 0;
sys_sem_t dup_addr_detect;
#if LWIP_SNTP
#include <time.h>
int lwip_sntp_start(int server_num, char **sntp_server, struct timeval *time)
{
// FIXME
return 0;
}
u32_t lwip_tftp_get_file_by_filename(u32_t ulHostAddr,
u16_t usTftpServPort,
u8_t ucTftpTransMode,
s8_t *szSrcFileName,
s8_t *szDestDirPath)
{
return 0;
}
u32_t lwip_tftp_put_file_by_filename(u32_t ulHostAddr,
u16_t usTftpServPort,
u8_t cTftpTransMode,
s8_t *szSrcFileName,
s8_t *szDestDirPath)
{
return 0;
}
#endif
const char *const tcp_state_str[] = {
"CLOSED",
"LISTEN",
"SYN_SENT",
"SYN_RCVD",
"ESTABLISHED",
"FIN_WAIT_1",
"FIN_WAIT_2",
"CLOSE_WAIT",
"CLOSING",
"LAST_ACK",
"TIME_WAIT"
"CLOSED",
"LISTEN",
"SYN_SENT",
"SYN_RCVD",
"ESTABLISHED",
"FIN_WAIT_1",
"FIN_WAIT_2",
"CLOSE_WAIT",
"CLOSING",
"LAST_ACK",
"TIME_WAIT"
};
volatile int tcpip_init_finish = 1; // needed by api_shell.c
#endif

1726
net/lwip-2.1/enhancement/src/tftpc.c Normal file
View File

File diff suppressed because it is too large Load Diff

19
net/lwip-2.1/porting/include/lwip/dhcp.h
View File

@ -32,13 +32,32 @@
#ifndef _LWIP_PORTING_DHCP_H_
#define _LWIP_PORTING_DHCP_H_
#include <lwip/opt.h>
#if LWIP_DHCPS
#define DHCP_OPTION_IDX_SERVER_ID DHCP_OPTION_IDX_SERVER_ID, \
DHCP_OPTION_IDX_REQUESTED_IP
#endif
#include_next <lwip/dhcp.h>
#if LWIP_DHCPS
#undef DHCP_OPTION_IDX_SERVER_ID
#endif
#include <lwip/prot/dhcp.h> // For DHCP_STATE_BOUND, DHCP_DISCOVER etc. by `mac/common/mac_data.c'
#ifdef __cplusplus
extern "C" {
#endif
#if LWIP_DHCPS
#define LWIP_HOOK_DHCP_PARSE_OPTION(netif, dhcp, state, msg, msg_type, option, len, pbuf, offset) \
LWIP_UNUSED_ARG(msg); \
break; \
case (DHCP_OPTION_REQUESTED_IP): \
LWIP_ERROR("len == 4", len == 4, return ERR_VAL); \
decode_idx = DHCP_OPTION_IDX_REQUESTED_IP;
#endif
err_t dhcp_is_bound(struct netif *netif);
#ifdef __cplusplus

4
net/lwip-2.1/porting/include/lwip/lwipopts.h
View File

@ -32,6 +32,7 @@
#ifndef _LWIP_PORTING_LWIPOPTS_H_
#define _LWIP_PORTING_LWIPOPTS_H_
#include "menuconfig.h"
// lwIP debug options, comment the ones you don't want
#if LWIP_DEBUG
@ -215,6 +216,9 @@
#define LWIP_CONFIG_NUM_SOCKETS 128
#define IP_REASS_MAX_MEM_SIZE (MEM_SIZE / 4)
// Options for enhancement code, same for old lwipopts.h
#define LWIP_NETIF_PROMISC 1
#define LWIP_TFTP LOSCFG_NET_LWIP_SACK_TFTP
#define LWIP_DHCPS 1
#define LWIP_ENABLE_NET_CAPABILITY 1

15
net/lwip-2.1/porting/include/lwip/netif.h
View File

@ -35,16 +35,23 @@
#include <net/if.h> // For IFNAMSIZ/IF_NAMESIZE and `struct ifreq', by `lwip/netif.h' and `api/sockets.c'
#include <netinet/ip.h> // For IP_OFFMASK, by `core/ipv4/ip4_frag.c'
struct dhcps;
#define netif_find netifapi_netif_find_by_name
#if LWIP_DHCPS
#define LWIP_NETIF_CLIENT_DATA_INDEX_DHCP LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, \
LWIP_NETIF_CLIENT_DATA_INDEX_DHCPS
#endif
#define linkoutput linkoutput; \
void (*drv_send)(struct netif *netif, struct pbuf *p); \
u8_t (*drv_set_hwaddr)(struct netif *netif, u8_t *addr, u8_t len); \
void (*drv_config)(struct netif *netif, u32_t config_flags, u8_t setBit); \
struct dhcps *dhcps; \
char full_name[IFNAMSIZ]; \
u16_t link_layer_type
#include_next <lwip/netif.h>
#undef linkoutput
#if LWIP_DHCPS
#undef LWIP_NETIF_CLIENT_DATA_INDEX_DHCP
#endif
#include <lwip/etharp.h> // For ETHARP_HWADDR_LEN, by `hieth-sf src/interface.c' and `wal/wal_net.c'
@ -64,9 +71,7 @@ err_t driverif_init(struct netif *netif);
void driverif_input(struct netif *netif, struct pbuf *p);
#ifndef __LWIP__
struct netif *netifapi_netif_find_by_name(const char *name);
#define PF_PKT_SUPPORT 1 // For netif->drv_config
#define netif_find(name) netifapi_netif_find_by_name(name)
#define PF_PKT_SUPPORT LWIP_NETIF_PROMISC
#define netif_add(a, b, c, d) netif_add(a, b, c, d, (a)->state, driverif_init, tcpip_input)
#else /* __LWIP__ */
#define netif_get_name(netif) ((netif)->full_name)

1
net/lwip-2.1/porting/include/lwip/netifapi.h
View File

@ -45,6 +45,7 @@ err_t netifapi_dhcps_stop(struct netif *netif);
#define netifapi_dhcp_is_bound(n) netifapi_netif_common(n, NULL, dhcp_is_bound)
void netifapi_netif_rmv_ip6_address(struct netif *netif, ip_addr_t *ipaddr);
struct netif *netifapi_netif_find_by_name(const char *name);
#ifndef __LWIP__
#define netifapi_netif_add(a, b, c, d) netifapi_netif_add(a, b, c, d, (a)->state, driverif_init, tcpip_input)

78
net/lwip-2.1/porting/src/driverif.c
View File

@ -44,7 +44,6 @@
#define link_rx_drop cachehit
#define link_rx_overrun cachehit
#define NETIF_NAME_LEN 2
#define LWIP_STATIC static
#ifndef LWIP_NETIF_IFINDEX_MAX_EX
@ -57,6 +56,9 @@ driverif_init_ifname(struct netif *netif)
struct netif *tmpnetif = NULL;
const char *prefix = (netif->link_layer_type == WIFI_DRIVER_IF) ? "wlan" : "eth";
netif->name[0] = prefix[0];
netif->name[1] = prefix[1];
for (int i = 0; i < LWIP_NETIF_IFINDEX_MAX_EX; ++i) {
if (snprintf_s(netif->full_name, sizeof(netif->full_name), sizeof(netif->full_name) - 1,
"%s%d", prefix, i) < 0) {
@ -140,7 +142,7 @@ driverif_input(struct netif *netif, struct pbuf *p)
#endif
#else
u16_t ethhdr_type;
struct eth_hdr* ethhdr = NULL;
struct eth_hdr *ethhdr = NULL;
#endif
err_t ret = ERR_VAL;
@ -241,7 +243,6 @@ err_t
driverif_init(struct netif *netif)
{
u16_t link_layer_type;
err_t ret;
if (netif == NULL) {
return ERR_IF;
@ -262,17 +263,7 @@ driverif_init(struct netif *netif)
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
#if LOSCFG_NET_LWIP_SACK_2_0
if (strncpy_s(netif->hostname, NETIF_HOSTNAME_MAX_LEN,
LWIP_NETIF_HOSTNAME_DEFAULT, NETIF_HOSTNAME_MAX_LEN - 1) == EOK) {
netif->hostname[NETIF_HOSTNAME_MAX_LEN - 1] = '\0';
} else {
LWIP_DEBUGF(DRIVERIF_DEBUG, ("driverif_init: hostname %s in invalid\n", LWIP_NETIF_HOSTNAME_DEFAULT));
netif->hostname[0] = '\0';
}
#else
netif->hostname = LWIP_NETIF_HOSTNAME_DEFAULT;
#endif
#endif /* LWIP_NETIF_HOSTNAME */
/*
@ -285,21 +276,6 @@ driverif_init(struct netif *netif)
netif->output = etharp_output;
netif->linkoutput = driverif_output;
if (link_layer_type == ETHERNET_DRIVER_IF) {
ret = memcpy_s(netif->name, sizeof(netif->name), "et", NETIF_NAME_LEN);
} else {
ret = memcpy_s(netif->name, sizeof(netif->name), "wl", NETIF_NAME_LEN);
}
if (ret != EOK) {
#if LWIP_NETIF_HOSTNAME
#if LOSCFG_NET_LWIP_SACK_2_0
netif->hostname[0] = '\0';
#else
netif->hostname = NULL;
#endif
#endif
return ERR_IF;
}
/* init the netif's full name */
driverif_init_ifname(netif);
@ -309,30 +285,30 @@ driverif_init(struct netif *netif)
/* device capabilities */
/* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP |
#if DRIVER_STATUS_CHECK
NETIF_FLAG_DRIVER_RDY |
#endif
#if LWIP_IGMP
NETIF_FLAG_IGMP |
#endif
#if DRIVER_STATUS_CHECK
NETIF_FLAG_DRIVER_RDY |
#endif
#if LWIP_IGMP
NETIF_FLAG_IGMP |
#endif
/**
@page RFC-2710 RFC-2710
@par Compliant Sections
Section 5. Node State Transition Diagram
@par Behavior Description
MLD messages are sent for multicast addresses whose scope is 2
(link-local), including Solicited-Node multicast addresses.\n
Behavior:Stack will send MLD6 report /Done to solicited node multicast address
if the LWIP_MLD6_ENABLE_MLD_ON_DAD is enabled. By default, this is disabled.
*/
/* Enable sending MLD report /done for solicited address during neighbour discovery */
#if LWIP_IPV6 && LWIP_IPV6_MLD
#if LWIP_MLD6_ENABLE_MLD_ON_DAD
NETIF_FLAG_MLD6 |
#endif /* LWIP_MLD6_ENABLE_MLD_ON_DAD */
#endif
NETIF_FLAG_LINK_UP;
/**
@page RFC-2710 RFC-2710
@par Compliant Sections
Section 5. Node State Transition Diagram
@par Behavior Description
MLD messages are sent for multicast addresses whose scope is 2
(link-local), including Solicited-Node multicast addresses.\n
Behavior:Stack will send MLD6 report /Done to solicited node multicast address
if the LWIP_MLD6_ENABLE_MLD_ON_DAD is enabled. By default, this is disabled.
*/
/* Enable sending MLD report /done for solicited address during neighbour discovery */
#if LWIP_IPV6 && LWIP_IPV6_MLD
#if LWIP_MLD6_ENABLE_MLD_ON_DAD
NETIF_FLAG_MLD6 |
#endif /* LWIP_MLD6_ENABLE_MLD_ON_DAD */
#endif
NETIF_FLAG_LINK_UP;
#if DRIVER_STATUS_CHECK
netif->waketime = -1;

46
net/lwip-2.1/porting/src/fixme.c
View File

@ -1,46 +0,0 @@
/*
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
*
* 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 of the copyright holder 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 HOLDER 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.
*/
#include <lwip/netif.h>
#include <lwip/dhcp.h>
err_t dhcp_is_bound(struct netif *netif)
{
return (netif_dhcp_data(netif) ? (netif_dhcp_data(netif)->state == DHCP_STATE_BOUND) ? ERR_OK : ERR_INPROGRESS : ERR_ARG);
}
#if (LWIP_CHKSUM_ALGORITHM == 4) /* version #4, asm based */
#include "in_cksum.h"
u16_t lwip_standard_chksum(const void *dataptr, int len)
{
return ~(u16_t)(in_cksum(dataptr, len));
}
#endif

14
net/lwip-2.1/porting/src/sockets.c
View File

@ -31,7 +31,7 @@
#include <lwip/sockets.h>
#include <lwip/priv/tcpip_priv.h>
#include <api_shell_fix.h>
#include <lwip/fixme.h>
#if LWIP_ENABLE_NET_CAPABILITY
#include "capability_type.h"
@ -39,8 +39,6 @@
#define BIND_SERVICE_CAP_MIN_PORT 1024
#endif
#define netif_find netifapi_netif_find_by_name
#define IOCTL_CMD_CASE_HANDLER() \
{ \
err_t err; \
@ -86,7 +84,8 @@ int lwip_bind(int s, const struct sockaddr *name, socklen_t namelen)
return lwip_bind_wrap(s, name, namelen);
}
static ssize_t lwip_sendto_wrap(int s, const void *dataptr, size_t size, int flags, const struct sockaddr *to, socklen_t tolen);
static ssize_t lwip_sendto_wrap(int s, const void *dataptr, size_t size, int flags,
const struct sockaddr *to, socklen_t tolen);
ssize_t lwip_sendto(int s, const void *dataptr, size_t size, int flags, const struct sockaddr *to, socklen_t tolen)
{
return lwip_sendto_wrap(s, dataptr, size, flags, to, tolen);
@ -233,12 +232,12 @@ static int lwip_bind_wrap(int s, const struct sockaddr *name, socklen_t namelen)
}
static ssize_t lwip_sendto_wrap(int s, const void *dataptr, size_t size, int flags,
const struct sockaddr *to, socklen_t tolen)
const struct sockaddr *to, socklen_t tolen)
{
#if LWIP_ENABLE_NET_CAPABILITY
if (to &&
((to->sa_family == AF_INET && tolen >= sizeof(struct sockaddr_in)) ||
(to->sa_family == AF_INET6 && tolen >= sizeof(struct sockaddr_in6)))) {
(to->sa_family == AF_INET6 && tolen >= sizeof(struct sockaddr_in6)))) {
ip_addr_t ipaddr;
u16_t port;
@ -372,7 +371,6 @@ int get_unused_socket_num(void)
// Options for lwip ioctl
#define LWIP_IOCTL_ROUTE 1
#define LWIP_IOCTL_IF 1
#define LWIP_NETIF_PROMISC 1
#define LWIP_NETIF_ETHTOOL 0
#define LWIP_IOCTL_IPV6DPCTD 0
#undef LWIP_IPV6_DUP_DETECT_ATTEMPTS
@ -764,7 +762,7 @@ static u8_t lwip_ioctl_internal_SIOCSIFNETMASK(struct ifreq *ifr)
loc_netif = loc_netif->next;
}
#if LWIP_DHCP // LWIP_DHCP
#if LWIP_DHCP
if ((netif_dhcp_data(netif) != NULL) &&
(netif_dhcp_data(netif)->state != DHCP_STATE_OFF)) {
(void)netif_dhcp_off(netif);

25
net/lwip-2.1/porting/src/sys_arch.c
View File

@ -46,6 +46,7 @@ static u32_t lwprot_thread = LOS_ERRNO_TSK_ID_INVALID;
static int lwprot_count = 0;
#endif /* LOSCFG_KERNEL_SMP == YES */
#define ROUND_UP_DIV(val, div) (((val) + (div) - 1) / (div))
/**
* Thread and System misc
@ -59,11 +60,11 @@ sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg,
/* Create host Task */
task.pfnTaskEntry = (TSK_ENTRY_FUNC)thread;
task.uwStackSize = stackSize;
task.uwStackSize = stackSize;
task.pcName = (char *)name;
task.usTaskPrio = prio;
task.auwArgs[0] = (UINTPTR)arg;
task.uwResved = LOS_TASK_STATUS_DETACHED;
task.uwResved = LOS_TASK_STATUS_DETACHED;
ret = LOS_TaskCreate(&taskID, &task);
if (ret != LOS_OK) {
LWIP_DEBUGF(SYS_DEBUG, ("sys_thread_new: LOS_TaskCreate error %u\n", ret));
@ -84,9 +85,17 @@ void sys_init(void)
u32_t sys_now(void)
{
/* Lwip docs mentioned like wraparound is not a problem in this funtion */
return (u32_t)(((double)LOS_TickCountGet() * OS_SYS_MS_PER_SECOND) / LOSCFG_BASE_CORE_TICK_PER_SECOND);
return (u32_t)((LOS_TickCountGet() * OS_SYS_MS_PER_SECOND) / LOSCFG_BASE_CORE_TICK_PER_SECOND);
}
#if (LWIP_CHKSUM_ALGORITHM == 4) /* version #4, asm based */
#include "in_cksum.h"
u16_t lwip_standard_chksum(const void *dataptr, int len)
{
return ~(u16_t)(in_cksum(dataptr, len));
}
#endif
/**
* Protector
@ -140,7 +149,7 @@ void sys_arch_unprotect(sys_prot_t pval)
err_t sys_mbox_new(sys_mbox_t *mbox, int size)
{
CHAR qName[] = "lwIP";
UINT32 ret = LOS_QueueCreate(qName, (UINT16)size, mbox, 0, sizeof(void*));
UINT32 ret = LOS_QueueCreate(qName, (UINT16)size, mbox, 0, sizeof(void *));
switch (ret) {
case LOS_OK:
return ERR_OK;
@ -184,8 +193,8 @@ err_t sys_mbox_trypost_fromisr(sys_mbox_t *mbox, void *msg);
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeoutMs)
{
void *ignore = 0; /* if msg==NULL, the fetched msg should be dropped */
UINT64 tick = ((UINT64)timeoutMs * LOSCFG_BASE_CORE_TICK_PER_SECOND + OS_SYS_MS_PER_SECOND - 1) / OS_SYS_MS_PER_SECOND;
UINT32 ret = LOS_QueueRead(*mbox, msg ? msg : &ignore, sizeof(void*), tick ? (UINT32)tick : LOS_WAIT_FOREVER);
UINT64 tick = ROUND_UP_DIV((UINT64)timeoutMs * LOSCFG_BASE_CORE_TICK_PER_SECOND, OS_SYS_MS_PER_SECOND);
UINT32 ret = LOS_QueueRead(*mbox, msg ? msg : &ignore, sizeof(void *), tick ? (UINT32)tick : LOS_WAIT_FOREVER);
switch (ret) {
case LOS_OK:
return ERR_OK;
@ -202,7 +211,7 @@ u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeoutMs)
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
{
void *ignore = 0; /* if msg==NULL, the fetched msg should be dropped */
UINT32 ret = LOS_QueueRead(*mbox, msg ? msg : &ignore, sizeof(void*), 0);
UINT32 ret = LOS_QueueRead(*mbox, msg ? msg : &ignore, sizeof(void *), 0);
switch (ret) {
case LOS_OK:
return ERR_OK;
@ -255,7 +264,7 @@ void sys_sem_signal(sys_sem_t *sem)
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeoutMs)
{
UINT64 tick = ((UINT64)timeoutMs * LOSCFG_BASE_CORE_TICK_PER_SECOND + OS_SYS_MS_PER_SECOND - 1) / OS_SYS_MS_PER_SECOND;
UINT64 tick = ROUND_UP_DIV((UINT64)timeoutMs * LOSCFG_BASE_CORE_TICK_PER_SECOND, OS_SYS_MS_PER_SECOND);
UINT32 ret = LOS_SemPend(*sem, tick ? (UINT32)tick : LOS_WAIT_FOREVER); // timeoutMs 0 means wait forever
switch (ret) {
case LOS_OK: